🚀 Launch Special: $29/mo for life --d --h --m --s Claim Your Price →
Coming Soon
Expected availability announced soon

This course is in active development. Preview the scope below and create a free account to be notified the moment it goes live.

Notify me
General Knowledge Coming Soon

JavaScript TypeScript

The course teaches core JavaScript concepts, modern ES6+ features, asynchronous patterns, DOM manipulation, and introduces TypeScript’s type system, generics, and utility types, enabling learners to build robust, typed web applications.

Who Should Take This

It is ideal for aspiring front‑end developers, recent computer‑science graduates, or self‑taught programmers who have little to no coding background but want to create interactive web experiences. Participants aim to master JavaScript fundamentals, adopt modern asynchronous techniques, and gain practical TypeScript skills for professional projects.

What's Included in AccelaStudy® AI

Adaptive Knowledge Graph
Practice Questions
Lesson Modules
Console Simulator Labs
Exam Tips & Strategy
20 Activity Formats

Course Outline

42 learning goals
1 JavaScript Core Language
2 topics

Variables, Types, and Operators

  • Declare variables using let, const, and var, explaining block scoping vs function scoping, the temporal dead zone for let/const, and why const does not make objects immutable.
  • Identify JavaScript's seven primitive types (string, number, bigint, boolean, undefined, null, symbol) and the object type, using typeof to inspect types and explaining why typeof null returns 'object'.
  • Explain type coercion rules and the difference between == (abstract equality) and === (strict equality), predicting the result of comparisons involving mixed types and truthy/falsy values.
  • Apply template literals for string interpolation and multiline strings, destructuring assignment for arrays and objects, spread/rest operators (...), and optional chaining (?.) with nullish coalescing (??).

Functions and Closures

  • Define functions using declarations, expressions, and arrow syntax, explaining hoisting behavior for declarations vs expressions and when arrow functions are preferred over function expressions.
  • Explain the four rules of this binding (default, implicit, explicit via call/apply/bind, and new) and how arrow functions inherit this lexically from their enclosing scope.
  • Explain closures as functions that retain access to their lexical scope and apply closures to implement data privacy, memoization, and factory functions.
  • Use higher-order functions that accept or return functions, implementing callback patterns and applying built-in array HOFs (map, filter, reduce) with function arguments.
2 Objects and Prototypes
2 topics

Objects and the Prototype Chain

  • Create objects using literal syntax, computed property names, shorthand properties, and method shorthand, and access properties using dot notation and bracket notation.
  • Explain the prototype chain and how property lookup traverses __proto__ links, using Object.create(), Object.getPrototypeOf(), and hasOwnProperty() to inspect and manipulate prototypes.
  • Use Object.keys(), Object.values(), Object.entries(), Object.assign(), and the spread operator to iterate, merge, and clone objects, distinguishing shallow from deep cloning behavior.

ES6 Classes

  • Define classes with constructor, instance methods, static methods, and private fields (#), explaining that ES6 classes are syntactic sugar over prototype-based inheritance.
  • Implement inheritance using extends and super, overriding methods in subclasses, and using instanceof to check the prototype chain at runtime.
  • Implement getters and setters in classes using get/set syntax, and apply Symbol.iterator to make custom objects iterable with for...of loops.
3 Arrays, Iterators, and Collections
2 topics

Array Methods and Patterns

  • Apply array transformation methods (map, filter, reduce, flat, flatMap) and search methods (find, findIndex, includes, some, every) to process collections declaratively instead of using imperative loops.
  • Chain multiple array methods to build data transformation pipelines, evaluating the performance and readability tradeoffs of method chaining versus single-pass reduce implementations.
  • Use Map and Set collections for key-value storage and unique element tracking, explaining their advantages over plain objects and arrays for specific use cases (non-string keys, guaranteed insertion order, O(1) lookup).

Iterators and Generators

  • Explain the iterable protocol (Symbol.iterator) and iterator protocol (next() returning {value, done}), and use for...of to iterate over built-in iterables (arrays, strings, Maps, Sets).
  • Write generator functions using function* and yield to produce lazy sequences, and apply generators to implement infinite sequences, custom iterables, and coroutine-like patterns.
4 Asynchronous JavaScript
2 topics

Event Loop and Promises

  • Explain the JavaScript event loop, call stack, callback queue, and microtask queue, predicting the order of execution for code mixing synchronous statements, setTimeout, and Promise.resolve().then().
  • Create and consume Promises using the Promise constructor, then/catch/finally chains, and explain the three states (pending, fulfilled, rejected) and how state transitions are irreversible.
  • Apply Promise combinators (Promise.all, Promise.race, Promise.allSettled, Promise.any) to coordinate multiple async operations, choosing the appropriate combinator for concurrent-all, first-wins, and fault-tolerant patterns.

Async/Await

  • Rewrite Promise chains using async/await syntax, explaining that async functions always return Promises and that await unwraps Promise values while pausing execution within the function.
  • Handle errors in async code using try/catch within async functions and .catch() on returned Promises, implementing proper error propagation in async call chains.
  • Evaluate sequential vs parallel async execution patterns, using Promise.all with await to run independent operations concurrently and avoiding the common mistake of unnecessary sequential awaits in loops.
5 DOM Manipulation and Events
2 topics

DOM Selection and Modification

  • Select DOM elements using querySelector, querySelectorAll, getElementById, and getElementsByClassName, and traverse the DOM tree using parentElement, children, nextElementSibling, and closest().
  • Modify element content (textContent, innerHTML), attributes (getAttribute, setAttribute, dataset), and classes (classList.add, remove, toggle, contains), and style elements programmatically.
  • Create, insert, and remove DOM elements using createElement, appendChild, insertBefore, replaceChild, remove(), and DocumentFragment for batch DOM updates that minimize reflows.

Events and Event Handling

  • Attach event listeners using addEventListener, explain the event object properties (target, currentTarget, type, preventDefault, stopPropagation), and describe the three phases of event propagation (capture, target, bubble).
  • Implement event delegation by attaching a single listener to a parent element and using event.target to handle events from dynamically created child elements, explaining why delegation is more efficient than per-element listeners.
6 Modules and Error Handling
2 topics

JavaScript Modules

  • Use ES module syntax (import/export, default exports, named exports, re-exports) and explain the differences between ES modules and CommonJS (require/module.exports) including static vs dynamic resolution.
  • Apply dynamic import() for code splitting and lazy loading, explaining when to use static imports vs dynamic imports based on bundle size and load-time requirements.

Error Handling

  • Implement try/catch/finally for synchronous error handling, distinguish Error types (TypeError, ReferenceError, SyntaxError, RangeError), and create custom Error subclasses with descriptive messages and stack traces.
7 TypeScript Type System
3 topics

TypeScript Fundamentals

  • Add type annotations to variables, function parameters, and return values using primitive types (string, number, boolean), arrays (number[], Array), tuples, and object types.
  • Define and implement interfaces and type aliases, explaining when to use each, and apply union types (A | B), intersection types (A & B), and literal types for precise type modeling.
  • Distinguish between any, unknown, never, and void types, explaining the type safety implications of each and when to use unknown instead of any for external data.
  • Use enums (numeric and string) and const assertions (as const) to define sets of named constants, explaining the tradeoffs between enum types and union literal types.

Advanced TypeScript Types

  • Write generic functions, classes, and interfaces using type parameters with constraints (extends), implementing reusable data structures and utility functions that maintain type safety.
  • Apply built-in utility types (Partial, Required, Readonly, Pick, Omit, Record, ReturnType, Parameters, Exclude, Extract) to derive new types from existing ones without duplication.
  • Narrow types using type guards (typeof, instanceof, in operator, custom type predicates with 'is'), discriminated unions with a shared tag field, and exhaustive switch patterns with never.
  • Create mapped types and conditional types to build type-level transformations, using keyof, indexed access types (T[K]), and template literal types for advanced type manipulation.

TypeScript Configuration

  • Configure a TypeScript project using tsconfig.json, setting target, module, strict mode options, moduleResolution, and paths, and explain how declaration files (.d.ts) provide types for JavaScript libraries.

Scope

Included Topics

  • JavaScript ES6+ fundamentals: let/const/var scoping, template literals, destructuring (arrays and objects), spread/rest operators, default parameters, arrow functions, and optional chaining (?.) and nullish coalescing (??).
  • Data types and type coercion: primitives (string, number, bigint, boolean, undefined, null, symbol), objects, typeof operator, equality comparisons (== vs ===), truthy/falsy values, and explicit type conversion.
  • Functions: function declarations vs expressions, arrow functions and lexical this, closures, IIFE, higher-order functions, callback patterns, and the arguments object vs rest parameters.
  • Object-oriented JavaScript: object literals, prototypes and the prototype chain, constructor functions, ES6 classes (constructor, methods, static, private fields #), inheritance with extends and super, and the new keyword.
  • Arrays and iterables: array methods (map, filter, reduce, find, findIndex, some, every, flat, flatMap, includes), for...of loops, iterators, generators (function*), and the Symbol.iterator protocol.
  • Asynchronous programming: the event loop and call stack, callbacks and callback hell, Promises (then, catch, finally, Promise.all, Promise.race, Promise.allSettled), async/await syntax, error handling in async code, and microtask vs macrotask queues.
  • DOM manipulation: selecting elements (querySelector, querySelectorAll, getElementById), modifying content (textContent, innerHTML), attributes and classes (classList), creating and removing elements, and event handling (addEventListener, event delegation, event bubbling and capturing).
  • Modules: ES modules (import/export, default exports, named exports, re-exports), CommonJS (require/module.exports) differences, dynamic import(), and module bundling concepts.
  • Error handling: try/catch/finally, Error types (TypeError, ReferenceError, SyntaxError, RangeError), custom error classes, and throwing errors.
  • TypeScript fundamentals: type annotations (primitives, arrays, objects, functions), interfaces, type aliases, union and intersection types, literal types, enums, and the any/unknown/never/void types.
  • TypeScript advanced types: generics (functions, classes, interfaces, constraints with extends), utility types (Partial, Required, Readonly, Pick, Omit, Record, ReturnType, Parameters), mapped types, conditional types, template literal types, and type narrowing with type guards (typeof, instanceof, in, custom type predicates).
  • TypeScript configuration and tooling: tsconfig.json basics (strict mode, target, module, moduleResolution), declaration files (.d.ts), and integrating TypeScript with JavaScript projects.

Not Covered

  • Frontend frameworks (React, Vue, Angular, Svelte) beyond incidental DOM references.
  • Node.js server-side APIs (http, fs, path, child_process) beyond module system differences.
  • Build tools configuration (Webpack, Vite, esbuild, Rollup) beyond conceptual awareness of bundling.
  • CSS, HTML, and web design beyond basic DOM manipulation.
  • Testing frameworks (Jest, Vitest, Cypress, Playwright) and test patterns.
  • Package management internals (npm, yarn, pnpm registry details) beyond basic install/publish.

JavaScript TypeScript is coming soon

Adaptive learning that maps your knowledge and closes your gaps.

Create Free Account to Be Notified