JavaScript Developer Study Guide
The CertifyForce JavaScript Developer study guide covers the official Salesforce JavaScript Developer exam outline in 24 units across all 7 exam sections, one unit per exam-guide topic. The exam itself has 60 scored questions plus 5 unscored, a 105-minute limit and a 65% passing score, and its largest section is Objects, Functions, and Classes at 25%. Every unit is verified against official Salesforce documentation, cites its sources, and links to the practice questions that test it. Last updated October 16, 2026.
Core JavaScript for the web stack, front end and back end: variables and types, objects, functions and classes, browser events and the DOM, asynchronous programming, Node.js, debugging, and testing. The skills apply to any framework, including Lightning Web Components.
24 lessons · 7 exam sections · about 3 h of reading ·
Exam sections
Unlock the full guide
Every lesson's summary, exam expectations, key facts and self-check questions are free to read. The JavaScript Developer pack unlocks the self-check answers, core concepts, exam traps and worked scenarios, reading progress, personalized “read next”, and unlimited practice exams.
Variables, Types, and Collections
23% of the exam- Declaring variables with var, let and const~7 minHow var, let and const differ in scope, hoisting, the temporal dead zone, re-declaration and reassignment, why const does not freeze objects, and the var-in-a-loop closure trap the exam loves.
- Strings, numbers and dates~6 minThe string, number and Date behaviors that decide 'what is logged' questions: immutable strings and slice vs substring, floating-point error and toFixed returning a string, parseInt vs Number, safe integers and BigInt, currency formatting with Intl.NumberFormat, zero-based months, UTC date-only parsing and date arithmetic.
- Type coercion and equality operators~6 minWhen JavaScript converts types on its own: + concatenation vs arithmetic, how objects become primitives through valueOf and toString, == vs === vs Object.is, relational comparison of strings, typeof surprises, explicit conversion with Number, String and Boolean, and the NaN checks that actually work.
- Truthy and falsy evaluations~5 minThe eight falsy values and why everything else (including '0', 'false', [] and {}) is truthy; how !, !!, Boolean(), && and || behave and what they return; and when ?? and ?. are the right defaults instead of ||.
- Array methods for data manipulation~6 minWhich array methods mutate and which return copies, what each one returns (map, filter, reduce, find, findIndex, some, every, includes, flat, forEach), the default string sort and comparators, shallow copies with spread, array destructuring, and Set and Map as collections.
- JSON parse and stringify~5 minTurning JSON text into objects and back: strict JSON syntax, navigating nested response data, the JSON.parse reviver, what JSON.stringify drops or converts (undefined, functions, Date, Map, NaN), replacer arrays and functions, indentation, toJSON, and the limits of a JSON round-trip deep copy.
Objects, Functions, and Classes
25% of the exam- Functions: arrows, parameters, this and callbacks~8 minHow to pick the right function form for a requirement: passing references versus calling, arrow function syntax and limits, default, rest and destructured parameters, the rules that decide this (including call, apply, bind and callbacks), higher-order helpers, IIFEs and generators.
- Objects: properties, prototypes and descriptors~7 minHow object literals, bracket and dot access, copies, the prototype chain and property descriptors behave, so you can pick the object technique a requirement needs and predict what keys, lookups, freeze and seal do.
- Classes: inheritance, private and static members~7 minHow class syntax maps onto constructor functions and prototypes, and how to use extends and super, private # fields, accessors, static members and Error subclasses to meet a requirement, including the ReferenceError, TypeError and SyntaxError traps.
- Modules: import, export and CommonJS~7 minHow to import and export from an ES module (named, default, namespace, aliases, re-exports and dynamic import), why imports are hoisted read-only live bindings evaluated once, what script type=module changes, and how CommonJS require/module.exports and Node's module-type rules differ.
- Scope, hoisting and closures~7 minHow JavaScript resolves a name through the lexical scope chain, what hoisting does to function declarations, var and let, how closures keep variables alive, and how calls, returns, recursion, switch fall-through and break/continue decide the order of output.
Browser and Events
17% of the exam- Events, listeners and propagation~8 minHow addEventListener registers, deduplicates and removes listeners, how an event travels through the capture, target and bubble phases, and how to choose between stopPropagation, stopImmediatePropagation and preventDefault, delegate events to a parent, and dispatch custom events with detail and bubbles.
- Selecting and manipulating the DOM~7 minWhich selection methods return static or live collections, how textContent, innerText and innerHTML differ (including the XSS risk), how to create, insert and remove nodes without destroying listeners, how attributes differ from properties and dataset, and how defer and DOMContentLoaded make sure the DOM exists before a script runs.
- Investigating code with browser DevTools~7 minWhich DevTools panel answers which question: the Elements inspector and DOM change breakpoints, Sources breakpoints for requests and event listeners, the Network panel's Preserve log and Disable cache, the Application panel's HttpOnly cookies, Performance long tasks, Memory heap snapshots for detached nodes, and the Console Utilities ($0, $$, getEventListeners, monitorEvents).
- Browser APIs: storage, fetch, timers and workers~7 minPick the browser API a requirement calls for: localStorage versus sessionStorage and the cross-tab storage event, fetch's resolve-on-404 rule and AbortController timeouts, debouncing with timers, requestAnimationFrame, IntersectionObserver, Web Workers, the History API and URLSearchParams, Geolocation and the Page Visibility API.
Debugging and Error Handling
7% of the exam- Throwing, catching and handling errors~6 minHow throw, try, catch and finally move control (including return in finally and rethrowing from nested handlers), why to throw Error objects, how to tell TypeError, RangeError, SyntaxError and ReferenceError apart with instanceof, where to place a handler for loops and async code, and when the global error and unhandledrejection events fire.
- Console methods and breakpoints~6 minWhich console method answers which debugging question (table, dir, group, count, time and timeEnd, assert, trace), why a logged object can show later values, and how line, conditional and logpoint breakpoints, the debugger statement, stepping, the Scope and Call Stack panes, and pause-on-exception settings help you inspect running code.
Asynchronous Programming
13% of the exam- Promises, async and await~7 minHow a promise settles once, how values and errors travel through then, catch and finally, which of Promise.all, allSettled, race and any fits a requirement, how to wrap a callback API in a promise, and how async functions and await behave, including sequential versus parallel awaits, missing await or return bugs, and top-level await.
- Event loop, microtasks and timers~6 minHow the call stack, task queue and microtask queue decide the order of synchronous code, promise callbacks, await continuations, queueMicrotask and setTimeout; why timer delays are minimums and long work blocks the page; how Node.js orders process.nextTick, promises, setImmediate and timers; and why errors thrown in timers escape try...catch.
Server Side JavaScript
8% of the exam- Node.js runtime: non-blocking I/O and scaling~7 minHow Node.js serves many connections from one thread, why synchronous and CPU-bound code stalls every request, and how to pick streams, worker_threads, cluster or child_process for large files, heavy computation and multi-core scaling.
- Node.js CLI commands and flags~6 minWhich node command fits the job: --check for a syntax-only pass, -e and -p for inline code, --require and --import to preload modules, --inspect and --inspect-brk for debugging, plus how arguments reach process.argv, how process.env is read and how the REPL works.
- Core Node.js modules: fs, path, http, events~6 minThe built-in modules the exam expects you to reach for: fs in its sync, callback and promise forms, path.join versus path.resolve and __dirname, http.createServer, EventEmitter ordering and the 'error' event, child_process, crypto hashing and util.promisify, and when a framework such as Express is worth a dependency.
- npm packages, semver ranges and lockfiles~6 minWhere npm saves a package (dependencies, devDependencies, --no-save, -g), what the caret, tilde and exact ranges let npm install, why package-lock.json is committed and npm ci used in CI, how npx and npm scripts reach local binaries, and what causes 'Cannot find module' in production.
Testing
7% of the examCommon questions about the JavaScript Developer study guide
Is the JavaScript Developer study guide free?
Partly. Every unit's summary and its "What the exam expects", "Key facts" and "Check yourself" sections are free to read without an account. The "Core concepts", "Exam traps" and "Worked scenario" sections, reading progress and unlimited timed mock exams come with the JavaScript Developer pack (USD $19).
How current is the JavaScript Developer study guide?
It is written to the current official Salesforce JavaScript Developer exam outline, and each unit is checked against Salesforce documentation before it is published. The most recent update was October 16, 2026, and every unit shows its own last-updated date.
How does the study guide map to the official JavaScript Developer exam guide?
There is one unit per topic in the official exam guide, grouped under its 7 weighted sections: Variables, Types, and Collections (23%), Objects, Functions, and Classes (25%), Browser and Events (17%), Debugging and Error Handling (7%), Asynchronous Programming (13%), Server Side JavaScript (8%), Testing (7%). Each unit quotes the exam objective it covers word for word.
How do the practice questions link to the study guide?
Each unit lists the reviewed practice questions that test it (300 questions are linked across the guide), so you can read a topic and practice it in one click. After a practice exam, every missed question links back to the unit that teaches it.