• Cert++
  • Practice
  • Certle
  • Review
  • Tracks
  • Checklist
  • Guides
  • Upgrade
Cert++
  1. Home
  3. 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

Given a scenario, apply asynchronous programming concepts.

0/8

Promise states: pending, fulfilled, and rejected, and how a Promise transitions between states

Learn this concept
Unseen

Promise chaining with .then(), .catch(), and .finally(): return values passed to the next .then()

Learn this concept
Unseen

async/await syntax: marking a function async so it returns a Promise and using await to pause execution

Learn this concept
Unseen

The return value of an async function and how it is automatically wrapped in a resolved Promise

Learn this concept
Unseen

Sequential versus parallel async operations: using await in a loop versus Promise.all with map

Learn this concept
Unseen

Promise.all(): runs promises in parallel and resolves when all resolve, or rejects on first rejection

Learn this concept
Unseen

Promise.allSettled(): resolves with an array of outcome objects regardless of individual promise results

Learn this concept
Unseen

Promise.race(): resolves or rejects as soon as the first promise in the iterable settles

Learn this concept
Unseen

Given a scenario, use event loop and event monitor or determine loop outcomes.

0/4

  • 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
  • Unit tests versus integration tests versus end-to-end tests: scope, speed, and isolation tradeoffs
  • Test structure with describe, it/test, beforeEach, afterEach, beforeAll, afterAll blocks
  • Common Jest/Jasmine matchers: toBe, toEqual, toBeTruthy, toBeFalsy, toThrow, toHaveBeenCalledWith
  • toBe versus toEqual: reference equality versus deep structural equality for objects and arrays
  • Identifying a test that does not assert the correct output and rewriting the assertion
  • Testing asynchronous code: using async/await or returning a Promise in a test case
  • Mocking and stubbing external dependencies (e.g., fetch, database calls) to isolate the unit under test
  • jest.fn() for creating mock functions versus jest.spyOn() for spying on existing methods
  • Spy functions: tracking calls and arguments to a function without altering its behavior
  • jest.mock() for auto-mocking an entire module so all its exports become jest.fn() stubs
  • toHaveBeenCalled, toHaveBeenCalledTimes, and toHaveBeenCalledWith matchers for verifying mock invocations
  • Test coverage concepts: identifying code paths (branches, lines) not exercised by a test suite

Prepare for the Exam

Play Today's Certle
Back to track

Study Community

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

Go to Discord

async/await syntax: marking a function async so it returns a Promise and using await to pause execution

Explainer

Learn More

Practice Question

Keep going

Next conceptThe return value of an async function and how it is automatically wrapped in a resolved Promise

Checklist progress

0/168 (0%)

0 of 168 concepts learned

Tip: You can filter concepts by status.

Prepare for the Exam

Play Today's Certle
Back to track

Study Community

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

Go to Discord

Explainer

Async functions provide a syntax for working with native promises that resembles traditional synchronous code. Introduced in ES2016+, this approach marks a function with the async keyword and uses await to handle promise resolution sequentially.

Core information
  • Marking a function with the async keyword wraps the call and ensures the function returns a Promise object.
More details and nuances
  • Error handling within async functions uses standard try/catch blocks instead of chaining .catch() methods.