Web Development · WDC-106

Advanced JavaScript

Advanced JavaScript is a course that takes modern JavaScript further, covering closures, classes, functional techniques, the event loop, Promises and async/await, ES modules, a first look at TypeScript, testing and building a REST API with Node.js and Express 5. It suits developers who already know the basics and want to write maintainable code for real projects.

Updated
From 6,750 THB / person 7,500 −10% excl. VAT 7% · group rates available
PDFDownload the course outline
  • Duration18 hours · 3 days
  • FormatOnsite / live online
  • Next roundOn request
  • CertificateIncluded

Course overview

JavaScript today is not only for web pages: it also powers server-side APIs, build tools and large applications. Developers who know the basics often start to struggle as their code grows, with this not holding the value they expect, asynchronous work running in the wrong order, errors disappearing silently, or a single file so long that nobody dares to change it, even though the language already has the tools to deal with all of this.

This course takes JavaScript to the level used in real projects. Learners set up Node.js, npm and Vite, get to grips with scope, closures and this, handle data with destructuring, spread and non-mutating array methods, and write functional and object-oriented code with classes. They then dig into the event loop, Promises, async/await, generators, ES modules and modern browser APIs, before building a REST API with Node.js and Express 5, starting with TypeScript, writing tests and looking after performance and security. The course closes with a capstone web app backed by a fully tested API. (3 days, 6 hours per day, 18 hours in total, Intermediate level.)

What you’ll gain

  • Explain scope, closures, this and the prototype chain, and use them to solve real problems
  • Handle data with modern ECMAScript features such as destructuring, spread and iterator helpers
  • Design object-oriented code with classes, private fields and composition
  • Understand the event loop and write correct asynchronous code with Promises and async/await
  • Organise projects with ES modules, npm and Vite
  • Build a REST API with Node.js and Express 5 with systematic error handling
  • Start using TypeScript and write automated tests for your own code
  • Check performance, memory leaks and common security flaws in JavaScript code

Who this course is for

  • Front-end and full-stack developers who know basic JavaScript and want to write it more systematically
  • Developers about to start with React, Vue, Angular or Node.js who want a deeper understanding of the language first
  • Developers maintaining older JavaScript code who want to modernise it
  • IT managers and tech leads who review code and set JavaScript standards for their team
  • Graduates of Basic JavaScript who want to take the next step

Prerequisites

  • Basic JavaScript, including variables, conditions, loops, functions, arrays and objects
  • Understanding of the DOM and the ability to handle events on a web page
  • Familiarity with HTML and CSS, and basic command-line and Git skills
  • A laptop that can run the current Node.js LTS release, VS Code and an up-to-date browser, with permission to install software

Curriculum

Course Details

This course is the 2026 edition of the Advanced JavaScript course. It runs for 3 days, 6 hours per day (18 hours in total, 09:00-16:00), as lectures with labs. Intermediate level. This edition goes beyond the ES6 features of the previous edition to the latest ECMAScript, including iterator helpers, Set methods, Promise.try and using declarations. It moves from Express 4 to Express 5 and

adds Vite, an introduction to TypeScript, testing with the Node.js test runner, and performance and security topics. Every lab uses open source tools on the learner's own machine. The course focuses on the language itself and Node.js, building on Basic JavaScript and laying the groundwork for React, Vue, Angular or NestJS. Learners take home a lab guide, starter and solution code for every lab, and their capstone project.

Day 1 Understanding the Language and Writing Modern Code

Section 1: Lab: Setting Up a Modern JavaScript Environment

  • ECMAScript from ES6 to the latest edition, and how to follow new features
  • Install the Node.js LTS release and use npm with package.json
  • Create a browser project with Vite
  • Set up ESLint and Prettier so the team writes code to one standard
  • Lab: a starter project used throughout the course

Section 2: Scope, Closures and this

  • Block scope, hoisting and the temporal dead zone
  • Closures and using them to keep private state
  • The value of this in normal functions, methods and arrow functions
  • call, apply and bind, and losing this in callbacks
  • Lab: a counter and a cache built from closures

Section 3: Lab: Handling Data with Modern Syntax

  • Destructuring arrays and objects with default values
  • Rest parameters and the spread operator
  • Optional chaining, nullish coalescing and structuredClone
  • Non-mutating array methods such as toSorted, toReversed and with
  • Grouping data with Object.groupBy and Map.groupBy

Section 4: Functional Programming in JavaScript

  • Higher-order functions and passing functions as values
  • Pure functions, immutability and function composition
  • map, filter and reduce for reporting on data
  • Iterator helpers and Set methods such as union and intersection
  • Lab: summarise sales from JSON data without changing the source data

Section 5: OOP with Classes and Prototypes

  • Classes, constructors, fields and methods
  • Private fields with #, static members, getters and setters
  • Inheritance with extends and super
  • The prototype chain working behind classes
  • Composition versus inheritance, and Lab: an object-oriented shopping cart
Day 2 Asynchronous Code, Modules and Browser APIs

Section 6: The Event Loop and Promises

  • Single-threaded JavaScript, the call stack and the event loop
  • Microtasks versus macrotasks and the real order of execution
  • Create and chain Promises with then, catch and finally
  • Promise.all, allSettled, any and race
  • Promise.withResolvers and Promise.try

Section 7: Lab: async/await and Error Handling

  • Write async/await instead of callbacks and promise chains
  • Handle errors with try, catch, finally and custom errors with cause
  • Cancel requests with AbortController and set timeouts
  • Run tasks in parallel with a concurrency limit, and retry on failure
  • Lab: a dashboard that fetches from several APIs at once

Section 8: Generators, Iterators and Releasing Resources

  • The iterable protocol and making objects work with for...of
  • Generator functions and yield
  • Async iterators and for await...of for data that arrives in chunks
  • Release resources automatically with using and await using
  • Lab: fetch paginated data with an async generator

Section 9: ES Modules and Build Tools

  • Named and default import and export
  • Dynamic import and top-level await
  • Organising a project into modules by responsibility
  • Installing npm packages, semantic versioning and lock files
  • Building and preparing files for production with Vite

Section 10: Lab: Modern Browser APIs

  • The Fetch API, Web Storage and an overview of IndexedDB
  • Intersection Observer for lazy loading and infinite scroll
  • Web Workers for heavy calculations without freezing the page
  • The Temporal API for dates and times, and checking browser support
  • Lab: a product list that loads more items as you scroll
Day 3 Node.js, Code Quality and Capstone

Section 11: Lab: A REST API with Node.js and Express 5

  • Commonly used Node.js modules and .env files with --env-file
  • Routing, middleware and splitting routers by responsibility
  • Express 5 passes errors from async handlers to error middleware automatically
  • Validate incoming data, configure CORS and respond with JSON
  • Lab: a product CRUD API with error handling

Section 12: TypeScript Basics for JavaScript Developers

  • Why most teams use TypeScript, and how to start with JSDoc
  • Basic types, interfaces, unions and simple generics
  • Run .ts files directly on Node.js with type stripping, and its limits
  • Lab: add types to the API from Section 11

Section 13: Lab: Writing Automated Tests

  • How unit tests and integration tests differ
  • Write tests with the Node.js test runner and node:assert
  • Mock functions and time, and test asynchronous code
  • Test the API with real requests and measure code coverage
  • Lab: write tests for the calculation functions and the product API

Section 14: Performance, Debugging and Security

  • Find slow code with the Performance panel and memory leaks with the Memory panel
  • Debounce and throttle for events that fire often
  • Preventing XSS and prototype pollution in JavaScript code
  • Check packages for vulnerabilities with npm audit
  • Use an AI assistant to review and refactor code, and verify the result with tests

Section 15: Workshop: Capstone Web App with an API

  • Design a Vite browser app that calls an Express 5 API
  • Organise it with ES modules and separate responsibilities
  • Write tests for the key parts and handle errors everywhere
  • Present the work, review code together and plan next steps towards React, Vue or NestJS

Schedule & training options

For individuals — public rounds

No public rounds are open right now. Join the waiting list and we will contact you first when the next round opens, or ask us on LINE. Or call 02-570-8449 or 088-807-9770

For organisations — in-house / private

  • Tailor the content to your team’s tools and projects
  • Your dates, at your office or live online
  • Quotation with tax ID for procurement
Corporate training quote

Instructors

Frequently asked questions

What is the difference between var, let and const in JavaScript?

var is function-scoped, can be redeclared and is hoisted with an initial value of undefined. let and const are block-scoped and cannot be used before their declaration because of the temporal dead zone. let can be reassigned and const cannot, although the contents of an object or array held in a const can still change. When you need a copy independent of the original, use structuredClone or non-mutating array methods such as toSorted.

How do you handle errors in async/await code?

Wrap the await calls in try...catch so rejected promises are caught, and use finally for work that must always run, such as clearing a loading state. With Promise.all, one failure rejects the whole batch, so use Promise.allSettled when you need every result. Use AbortController to set a timeout on requests that might hang, and note that in Express 5 errors from async handlers are passed to the error middleware automatically.

How does the event loop work in JavaScript?

JavaScript runs code on a single thread. Work that has to wait, such as timers or network calls, is handed to the browser or Node.js, and its callback is queued when it finishes. The event loop waits until the call stack is empty, then runs every queued microtask, such as promise callbacks, before taking the next macrotask, such as a setTimeout callback. Heavy calculations are therefore best moved to a Web Worker so the page does not freeze.

Who is the Advanced JavaScript course for, and what should I know beforehand?

It suits front-end and full-stack developers, developers about to start with React, Vue, Angular or Node.js, people maintaining older JavaScript code and tech leads who review their team's code. You should be able to write basic JavaScript, including variables, conditions, loops, functions, arrays and objects, understand the DOM and events, and use the command line and Git at a basic level. Graduates of Basic JavaScript can continue straight on.

What will I be able to do after the Advanced JavaScript course?

You will understand mechanisms such as closures, this, prototypes and the event loop, write code with the latest ECMAScript features, structure code in functional and object-oriented styles, handle asynchronous work with Promises and async/await, organise projects with ES modules and Vite, build a REST API with Node.js and Express 5, start using TypeScript and write automated tests. Participants who complete the training receive a Certificate of Completion with its own number, which can be verified online.

Can the Advanced JavaScript course be run in-house for our team?

Yes. It can be run in-house for your team, with examples adapted to your own work, such as modernising the JavaScript code or APIs your team already maintains and adding tests to them. You can request a quotation from this page, or contact us on LINE @itgenius or by phone on 02-570-8449.

Related articles

Articles are published in Thai.