Cert++

Practice
Certle
Review
Tracks
Checklist
Guides
Upgrade

Home
JavaScript Developer

JavaScript Developer

Checklist progress

0/168Learned

JavaScript Developer

Study Checklist

Platform Administrator
Platform App Builder
Platform Foundations
Platform Developer
Platform Administrator II
Agentforce Sales Consultant
Agentforce Service Consultant
Platform Data Architect
Platform Development Lifecycle and Deployment Architect
Platform Identity and Access Management Architect
Platform Integration Architect
Platform Sharing and Visibility Architect
Heroku Architect
B2C Solution Architect
Experience Cloud Consultant
Agentforce Field Service and Operations Consultant
Agentforce Nonprofit Consultant
Data 360 Consultant
Omnistudio Consultant
CRM Analytics and Einstein Discovery Consultant
Platform User Experience Designer
Platform Strategy Designer
B2C Commerce Developer
JavaScript Developer
Omnistudio Developer
Platform Developer II
Marketing Cloud Engagement Administrator
Marketing Cloud Engagement Specialist
Marketing Cloud Engagement Consultant
Agentforce Sales Foundations
Business Analyst
Marketing Cloud Engagement Developer
Marketing Cloud Engagement Foundations
Agentforce Specialist
Agentforce Life Sciences Consultant
B2B Commerce Administrator AP
B2B Commerce Developer AP
Agentforce Consumer Goods AP
Agentforce Financial Services AP
Agentforce Health AP
Agentforce Manufacturing AP
MuleSoft Integration Foundations
MuleSoft Developer
MuleSoft Developer II
MuleSoft Platform Integration Architect
MuleSoft Platform Architect
Tableau Desktop Foundations
Tableau Data Analyst
Tableau Consultant
Tableau Server Administrator
Tableau Architect

Checklist progress

0/168Learned

Difference between var, let, and const in terms of scope and hoisting behavior
Block scoping with let and const versus function scoping with var
How var declarations are hoisted to the top of their function scope and initialized to undefined
Temporal dead zone (TDZ) behavior for let and const declarations before initialization
Destructuring assignment for arrays and objects to extract and initialize variables
Rest parameters (...args) for collecting variable-length arguments into an array
Classic var-in-for-loop closure trap: all loop iterations share one var binding versus per-iteration let binding
Default parameter values in function signatures
Template literals (backtick strings) for multi-line strings and expression interpolation
String search methods: indexOf, includes, startsWith, endsWith
String extraction and splitting: slice, substring, split
String modification methods: replace, trim, padStart, padEnd, repeat
Number parsing: Number.parseInt and Number.parseFloat
Number formatting with toFixed for decimal places
Number validation methods: Number.isInteger, Number.isFinite, Number.isNaN
Math rounding methods: Math.floor, Math.ceil, Math.round
Math comparison and absolute value: Math.max, Math.min, Math.abs
Date object creation with new Date() and getter methods: getFullYear, getMonth, getDate, getTime
Date serialization: toISOString and toLocaleDateString for string output
typeof operator return values for all primitive types and objects (including typeof null === 'object')
Explicit type conversion using String(), Number(), Boolean(), parseInt(), and parseFloat()
Implicit type coercion with the + operator when mixing strings and numbers
Abstract equality (==) versus strict equality (===) and the coercion rules applied
Coercion behavior when using arithmetic operators on null, undefined, and boolean values
NaN comparison behavior: NaN !== NaN is true; use Number.isNaN() to detect it
Optional chaining operator (?.) for safely accessing nested properties that may be null or undefined
The six falsy values in JavaScript: false, 0, '', null, undefined, NaN
Truthy evaluation of objects, arrays, non-zero numbers, and non-empty strings in conditional expressions
Short-circuit evaluation with && and || operators using truthy/falsy logic
Nullish coalescing operator (??) versus logical OR (||) for default value assignment
Array methods that mutate the original array: push, pop, shift, unshift, splice, sort, reverse, fill
Array methods that return a new array: map, filter, slice, concat, flat, flatMap
Array iteration methods: forEach, reduce, find, findIndex, some, every, includes
for...of loop for iterating over arrays and other iterables versus for...in for object keys
Sorting arrays of objects using a comparator function with Array.prototype.sort
Array destructuring to extract values into named variables including skipping elements
Spread operator (...) for cloning arrays and combining arrays
Array.from() for creating arrays from array-like objects and iterables
JSON.parse() to convert a JSON string into a JavaScript object
Accessing nested properties of a parsed JSON object using dot and bracket notation
JSON.stringify() to serialize a JavaScript object to a JSON string, including the replacer and space parameters
JSON.stringify behavior with undefined, functions, and Symbol values (they are omitted)

Function declaration hoisting versus function expression (not hoisted) behavior
Arrow functions versus regular functions: syntax differences and behavior of the this keyword
call(), apply(), and bind() methods for explicitly setting the this context of a function
Closures: inner functions retaining access to outer function's variable scope after the outer function returns
Higher-order functions: functions that accept or return other functions
Pure functions versus functions with side effects, and the importance of referential transparency
Immediately Invoked Function Expressions (IIFE) syntax and use case for creating private scope
Generator functions (function*) with yield: creating iterators for lazy value generation
Object literal syntax: shorthand property names, computed property names, and method shorthand
Prototype chain and how property lookup traverses the chain
Object.create() for creating an object with a specified prototype (prototypal inheritance without classes)
instanceof operator: checking whether an object's prototype chain includes the prototype of a given constructor
hasOwnProperty() and Object.hasOwn() for distinguishing own properties from inherited prototype properties
Object.keys(), Object.values(), Object.entries() for iterating over an object's own enumerable properties
Object spread operator (...) for cloning and merging objects (shallow copy)
Object.assign() for shallow copying or merging objects
Map collection: key-value pairs, its methods, and when to use over plain objects
Set collection: unique values only, its methods, and when to use over plain arrays
Object.freeze() and its effect on object mutability (prevents all changes)
Object destructuring with renaming and default values
ES6 class declaration syntax: constructor, instance methods, and creating instances with new
Classes are syntactic sugar over prototype-based inheritance: the prototype chain still underlies class instances
Class inheritance with extends and super() for calling the parent constructor and parent methods
Public class fields: declaring instance properties directly in the class body without the constructor
Getters and setters in classes using get and set keywords
Static methods and static properties on classes: when and how they differ from instance methods
Private class fields (#fieldName) and their access restriction within the class body
Module scope: variables declared in a module are not global and are private to that module by default
ES module syntax: named exports versus default exports
Importing a default export and the difference from named import syntax
Importing named exports with destructuring syntax and renaming with 'as'
CommonJS module syntax (require/module.exports) versus ES module syntax (import/export)
Dynamic import() for lazy loading modules and its Promise-based return
Decorator syntax (@decoratorName) placement on classes and class members
How a method decorator receives target, propertyKey, and descriptor arguments
How a class decorator receives the constructor as its argument and can modify or wrap it
Execution context and the call stack: how function calls push and pop execution contexts
Lexical scoping: how inner functions access variables from enclosing scopes at the time the function is defined
The value of this in different contexts: global, method call, constructor call, and arrow functions
Variable shadowing: inner scope declaration hiding an outer scope variable of the same name

Common event types: click, input, change, submit, keydown, keyup, focus, blur, load, DOMContentLoaded
addEventListener syntax: event type, listener callback, and optional useCapture/options parameter
Event bubbling versus event capturing phases and the order events propagate through the DOM
event.target versus event.currentTarget: the element that triggered the event versus the element the listener is attached to
event.stopPropagation() to halt event bubbling
event.preventDefault() to cancel the default browser action
Event delegation: attaching a single listener on a parent element to handle events from child elements using event.target
removeEventListener: correct usage requires a reference to the same function instance used in addEventListener
Custom events using new CustomEvent() with a detail payload and dispatching with dispatchEvent()
Single-element DOM selection: getElementById and querySelector
Collection DOM selection: querySelectorAll, getElementsByClassName, getElementsByTagName (live HTMLCollection vs static NodeList)
Traversing the DOM: parentNode, children, firstElementChild, lastElementChild, nextElementSibling
Creating DOM elements with createElement
Inserting DOM nodes: appendChild, append, insertBefore, prepend
Removing DOM nodes: removeChild, element.remove()
Modifying element content: textContent versus innerHTML (and security implications of innerHTML with user input)
Modifying element attributes: getAttribute, setAttribute, removeAttribute, dataset property
classList API: add, remove, toggle, contains for CSS class manipulation
Inline style manipulation via element.style and reading computed styles with getComputedStyle()
Using the console panel: console.log, console.error, console.warn, console.table, console.group
Setting breakpoints in the Sources panel and stepping through code (Step Over, Step Into, Step Out)
Using the Watch and Scope panels to inspect variable values at a breakpoint
Inspecting network requests in the Network panel: request/response headers, status codes, payload
Fetch API: making GET and POST requests, handling the Response object, and parsing JSON
Fetch API request options: method, headers, body, mode, and credentials
setTimeout and setInterval: scheduling code execution and clearing timers with clearTimeout/clearInterval
Web Storage API: setItem, getItem, removeItem, and clear methods
Difference between localStorage (persists until cleared) and sessionStorage (cleared when tab closes)
window.location properties for reading URL parts: href, pathname, search, hash
window.location methods for navigation: assign(), replace(), reload()
URL and URLSearchParams APIs for constructing and parsing URLs and query parameters
History API: pushState, replaceState, popstate event for single-page app navigation
requestAnimationFrame for scheduling visual updates in sync with the browser repaint cycle

try/catch/finally block structure: what executes in each block and when finally runs
The Error object properties: message, name, and stack
Throwing custom errors: throw new Error('message') and throw new TypeError, RangeError, etc.
Catching errors in async/await code using try/catch versus .catch() on a Promise chain
Re-throwing errors in a catch block to propagate to a higher handler
Creating custom Error subclasses using class MyError extends Error with a constructor that sets name
finally block behavior when a return or throw statement appears inside try or catch blocks
The debugger statement as a programmatic breakpoint in source code
Conditional breakpoints: pausing execution only when a specified condition is true
console.time() and console.timeEnd() for measuring elapsed time between two points in code
console.assert() for logging an error message only when a condition is false

Promise states: pending, fulfilled, and rejected, and how a Promise transitions between states
Promise chaining with .then(), .catch(), and .finally(): return values passed to the next .then()
async/await syntax: marking a function async so it returns a Promise and using await to pause execution
The return value of an async function and how it is automatically wrapped in a resolved Promise
Sequential versus parallel async operations: using await in a loop versus Promise.all with map
Promise.all(): runs promises in parallel and resolves when all resolve, or rejects on first rejection
Promise.allSettled(): resolves with an array of outcome objects regardless of individual promise results
Promise.race(): resolves or rejects as soon as the first promise in the iterable settles
The JavaScript event loop: call stack, Web APIs, callback queue (macro-task queue), and microtask queue
Microtasks (Promise callbacks) execute before the next macro-task (setTimeout callback)
Output ordering when mixing synchronous code, setTimeout(fn, 0), and resolved Promise .then() callbacks
How unhandled Promise rejections are detected and surfaced in Node.js vs the browser

Node.js event-driven, non-blocking I/O model and when it is appropriate versus thread-based approaches
The process object: process.argv, process.env, process.exit(), process.stdout, and process.cwd()
Reading and writing files with the fs module: fs.readFile, fs.writeFile, fs.appendFile (callback and promise variants)
Creating an HTTP server with the http module using http.createServer and server.listen
node command: running a script with node filename.js and passing arguments via process.argv
npx: running a package binary without installing it globally, and how it differs from npm run
Environment variables in Node.js via process.env and setting them at the command line
Core Node.js built-in modules: path, os, fs, http, https, events, crypto, util, url
path.join() and path.resolve() for constructing cross-platform paths
Express.js routing: defining routes with HTTP methods and path patterns
Express.js request and response objects: properties and methods for handling HTTP
Express.js middleware: order of execution, next(), and modifying request/response
package.json structure: name, version, scripts, dependencies, devDependencies, and engines fields
npm install versus npm install --save-dev: difference between runtime and development dependencies
npm scripts: defining and running custom commands in the scripts section of package.json
Semantic versioning (semver): major, minor, and patch version increments and the ^ and ~ range specifiers
npm versus yarn: key command differences and use cases for each
package-lock.json and yarn.lock: purpose of lock files in reproducible builds

With a block of code and the associated Unit Test, determine where the test is ineffective and modify it to make it more effective.

0/12

Unit tests versus integration tests versus end-to-end tests: scope, speed, and isolation tradeoffs

Learn this concept

Unseen

Test structure with describe, it/test, beforeEach, afterEach, beforeAll, afterAll blocks

Learn this concept

Unseen

Common Jest/Jasmine matchers: toBe, toEqual, toBeTruthy, toBeFalsy, toThrow, toHaveBeenCalledWith

Learn this concept

Unseen

toBe versus toEqual: reference equality versus deep structural equality for objects and arrays

Learn this concept

Unseen

Identifying a test that does not assert the correct output and rewriting the assertion

Learn this concept

Unseen

Testing asynchronous code: using async/await or returning a Promise in a test case

Learn this concept

Unseen

Mocking and stubbing external dependencies (e.g., fetch, database calls) to isolate the unit under test

Learn this concept

Unseen

jest.fn() for creating mock functions versus jest.spyOn() for spying on existing methods

Learn this concept

Unseen

Spy functions: tracking calls and arguments to a function without altering its behavior

Learn this concept

Unseen

jest.mock() for auto-mocking an entire module so all its exports become jest.fn() stubs

Learn this concept

Unseen

toHaveBeenCalled, toHaveBeenCalledTimes, and toHaveBeenCalledWith matchers for verifying mock invocations

Learn this concept

Unseen

Test coverage concepts: identifying code paths (branches, lines) not exercised by a test suite

Learn this concept

Unseen

Prepare for the Exam

Play Today's Certle

Study Community

Ask questions and get the latest info from other JavaScript Developer studiers. 593 members and growing.

toBe versus toEqual: reference equality versus deep structural equality for objects and arrays

Explainer

Learn More

Practice Question

Keep going

Next conceptIdentifying a test that does not assert the correct output and rewriting the assertion

Checklist progress

0/168 (0%)

0 of 168 concepts learned

Learned0Learning0Seen0Unseen168

Tip: You can filter concepts by status.

Prepare for the Exam

Play Today's Certle

Study Community

Ask questions and get the latest info from other JavaScript Developer studiers. 593 members and growing.

Explainer

toBe uses strict reference equality (Object.is) to compare values — correct for primitives but wrong for objects and arrays. toEqual recursively checks that two objects or arrays have the same structure and values, regardless of whether they are the same reference.