Cert++
  1. Home
  3. JavaScript Developer

JavaScript Developer

Checklist progressProgress

0/233Learned

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
  • Slack Administrator

Checklist progressProgress

0/233Learned

  • Legal variable identifiers and case sensitivity
  • Primitive data types and typeof results for declared values
  • undefined, null and undeclared variables
  • Block scope versus function scope for var, let and const
  • const declaration initializer and reassignment rules
  • const bindings holding mutable objects and arrays
  • Object literal property shorthand and computed property names
  • Array destructuring with skipped, default and rest elements
  • Object destructuring with renaming, defaults and nesting
  • Redeclaration errors versus shadowing in nested blocks
  • Hoisting of var versus the temporal dead zone for let and const
  • Loop counters declared with let versus var inside closures
  • Template literals for interpolation and multiline text
  • String case, trim and pad methods on immutable strings
  • Extracting characters and substrings from strings
  • String search methods and their return values
  • Replacing text with replace, replaceAll, and regular expressions
  • Arithmetic operator precedence, remainder and exponent
  • Prefix versus postfix increment and compound assignment
  • Number() versus parseInt(), parseFloat() and unary plus
  • Correcting unintended concatenation of numeric strings
  • NaN and Infinity results and their detection
  • Math object rounding, range, and random methods
  • Rounding and formatting numbers for display
  • Floating-point precision, safe integers and BigInt
  • Creating Date objects from components, strings, and timestamps
  • Date get and set methods and component ranges
  • Date arithmetic and comparison with timestamps
  • Formatting dates and handling UTC versus local time
  • String concatenation versus numeric addition with the plus operator
  • Implicit number conversion by arithmetic and unary operators
  • String conversion with String(), toString() and template literals
  • Loose equality versus strict equality comparisons
  • Relational comparisons between strings, numbers and null
  • Object and array conversion to primitives in expressions
  • Property key coercion to strings in objects and arrays
  • Primitive auto-wrapping versus explicit wrapper objects
  • Falsy values in conditional evaluation
  • Truthiness of empty arrays, empty objects and non-empty strings
  • Explicit boolean conversion with double NOT and Boolean()
  • Operand values returned by logical OR and AND
  • Short-circuit evaluation and skipped side effects
  • Logical OR defaults versus nullish coalescing for valid falsy inputs
  • Truthiness versus loose equality with true or false
  • Array creation with literals, the Array constructor and Array.from
  • Array length, index assignment and empty slots
  • Adding and removing elements at either end of an array
  • splice for inserting, removing and replacing elements
  • for...of versus for...in versus forEach over arrays
  • forEach versus map for transforming elements
  • filter predicates and the elements they keep
  • Searching arrays and testing elements against a condition
  • reduce accumulators and the initial value
  • Chaining filter, map and reduce over a list of objects
  • Converting between arrays and strings
  • Default array sort order versus comparator functions
  • Mutating versus non-mutating array methods
  • Copying and merging arrays versus sharing a reference
  • Nested arrays and flattening
  • Set and Map keyed collections for deduplication and lookup
  • JSON text versus parsed values with parse and stringify
  • Valid JSON syntax versus JavaScript object literals
  • Navigating nested values in a parsed JSON response
  • Optional chaining versus the TypeError from reading through missing objects
  • Reading JSON from a fetch response with response.json()
  • JSON.stringify output for special values, Dates and toJSON
  • Replacer, space and reviver arguments of JSON methods
  • Deep copying objects with a JSON round-trip
  • Function parameters, arguments, and return values
  • Primitive versus object arguments passed to functions
  • Arrow function syntax and implicit returns
  • When to use arrow functions versus regular functions
  • Default parameters versus logical OR fallbacks
  • Destructured options parameters with default values
  • Rest parameters versus the arguments object
  • Spread syntax versus rest syntax around function calls
  • Higher-order functions and callback references
  • Recursive functions and base cases
  • Generator functions and yield
  • Object literal syntax: methods, shorthand properties, and JSON contrast
  • Dot versus bracket notation and dynamic property keys
  • Checking for and deleting object properties
  • Enumerating object keys, values, and entries
  • Object references, mutation, and identity comparison
  • Copying and merging objects with spread and Object.assign
  • Constructor functions and the new operator
  • Prototype chain lookup, property shadowing, and instanceof
  • Choosing between object literals, constructor functions, and Object.create
  • Restricting object changes with freeze, seal, and non-writable properties
  • ES6 class syntax versus prototype-based constructor functions
  • Class body member syntax and constructor rules
  • Class declaration hoisting and class expressions
  • Static methods and fields versus instance methods
  • Getters and setters in classes and object literals
  • Public class fields and instance initialization order
  • Private class fields and methods with # syntax
  • Derived class constructors and super() calls
  • Method overriding and calling parent methods via super
  • Named exports and matching named imports
  • Default export and default import syntax
  • Renaming imports and exports with the as keyword
  • Namespace imports and the module namespace object
  • Re-exporting and aggregating modules through a barrel file
  • Loading ES modules in the browser with script type module
  • Module scope, strict mode, and one-time evaluation
  • Read-only live bindings of imported values
  • Dynamic import() for loading modules on demand
  • CommonJS require versus ES module import in Node.js
  • Lexical scope chain resolution in nested functions
  • Variable shadowing across global, function, and block scopes
  • Global scope bindings and implicit globals in strict versus sloppy mode
  • Function declarations versus function expressions and hoisting
  • break, continue, and switch fall-through in execution flow
  • Closures retaining and updating captured variable state
  • Private state with closures and the IIFE module pattern
  • this context determined by how a function is invoked
  • call, apply, and bind for an explicit this context
  • Preserving this inside nested callbacks
  • Event handler properties versus addEventListener
  • Registering a handler: function reference versus invocation
  • Removing event listeners and one-time listeners
  • Choosing mouse, keyboard, focus and form event types
  • Pointer events for mouse, touch and pen input
  • The event object: target, currentTarget and this in handlers
  • preventDefault and default browser actions
  • Event bubbling order through ancestor elements
  • Capture phase listeners and mixed capture/bubble ordering
  • Multiple listeners on one target: invocation order and duplicates
  • stopPropagation versus stopImmediatePropagation
  • Event delegation for dynamically added child elements
  • Creating and dispatching events: CustomEvent and synchronous dispatchEvent
  • Debouncing and throttling high-frequency event handlers
  • DOM tree nodes and traversal properties
  • DOM element selection methods and what they return
  • textContent versus innerText versus innerHTML
  • HTML attributes versus DOM element properties
  • Styling elements with classList, className and the style property
  • Creating, inserting, moving and removing DOM nodes
  • Page load events and script timing before DOM manipulation
  • Choosing the right DevTools panel for an investigation task
  • Inspecting paused state with Watch, Scope and Call Stack
  • Using the Console in a paused scope to evaluate and modify variables
  • Pause on caught versus uncaught exceptions
  • Browser host objects and Web APIs beyond core JavaScript
  • Choosing client-side storage: localStorage, sessionStorage or cookies
  • Web Storage reads and writes with string-only values
  • Timer APIs for scheduling and cancelling callbacks
  • Fetch API requests and Response handling
  • History API navigation methods
  • pushState, replaceState, and the popstate event
  • try...catch...finally forms and execution flow
  • Built-in error types raised by common runtime mistakes
  • Error name, message and cause properties
  • Throwing Error objects versus arbitrary values
  • Custom error classes extending Error
  • Selective catching with instanceof and rethrowing
  • Exception propagation through nested try blocks and the call stack
  • Return and throw statements inside finally blocks
  • Errors that escape try...catch in asynchronous code
  • Console logging methods and log levels
  • Choosing console methods for structured, counted and timed output
  • Runtime assertions with console.assert
  • Tracing the call path with console.trace and the call stack
  • The debugger statement versus DevTools line-of-code breakpoints
  • Stepping controls while paused: step over, into, out and resume
  • Conditional breakpoints for pausing on a specific value or iteration
  • Choosing a DevTools breakpoint type for a debugging scenario

Given a scenario, apply asynchronous programming concepts

0/17

  • Callback functions and the error-first callback convention
  • Callback hell versus flat promise chains
  • Promise states and settlement terminology
  • Promise constructor settlement rules for resolve, reject and throw
  • Wrapping callback-based APIs in a Promise
  • Values passed along a then() chain
  • Rejection propagation and recovery in promise chains
  • catch() versus then() rejection handlers and nested catch scope
  • finally() handler behavior in promise chains
  • Consuming fetch() responses in a promise chain
  • Promise.all versus Promise.allSettled
  • Promise.race versus Promise.any
  • Async function return values and reading them with await
  • Where await is permitted and async declaration forms
  • Error handling with try/catch around await
  • Sequential awaits versus concurrent Promise.all
  • Preserving this in timer and asynchronous callbacks

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

0/10

Call stack, task queue and event loop roles in the runtime

Learn this concept
Unseen

Synchronous statements versus zero-delay setTimeout callbacks

Learn this concept
Unseen

Multiple timer ordering and delays as minimum waits

Learn this concept
Unseen

setTimeout callbacks inside loops with var versus let

Learn this concept
Unseen

Promise microtasks versus setTimeout macrotasks

Learn this concept
Unseen

Promise executor timing versus then handler timing

Learn this concept
Unseen

Async function execution before and after await

Learn this concept
Unseen

Tasks and microtasks scheduled from inside other callbacks

Learn this concept
Unseen

await inside forEach versus for...of loops

Learn this concept
Unseen

Synchronous dispatchEvent versus natively queued events

Learn this concept
Unseen
  • Node.js runtime globals versus browser-only APIs
  • Non-blocking I/O in Node.js and the workloads it suits
  • CommonJS versus ES modules in a Node.js project
  • CommonJS exports versus module.exports
  • Basic HTTP server with the Node.js http module
  • Using cluster, worker_threads and child_process in a Node.js app
  • Launching a Node.js app with node versus npm start
  • Node.js REPL sessions and dot commands
  • Passing arguments and environment variables to a node process
  • Common node command-line options
  • Debugging a Node.js script from the command line
  • Matching a requirement to a core Node.js module
  • fs callback, synchronous, and promise-based APIs
  • EventEmitter custom events with the events module
  • Streams versus whole-file reads for large data
  • Outbound HTTP and HTTPS requests from a Node.js server
  • Bare http module versus the Express framework
  • Choosing a Node.js framework or library for a requirement
  • package.json manifest fields and npm init scaffolding
  • dependencies versus devDependencies versus peerDependencies
  • Local versus global package installs and npx
  • npm scripts and lifecycle hooks in package.json
  • Semantic versioning increments when releasing a package
  • Semver range operators in package.json dependencies
  • package-lock.json and npm ci versus npm install
  • npm workspaces in a multi-package project
  • npm versus Yarn and other Node.js package managers
  • Unit, integration, and end-to-end test scope
  • JavaScript testing tools and ways to run tests
  • console.assert checks as lightweight unit tests
  • BDD test suite anatomy with describe, it and expect
  • Matcher choice and assertion strength
  • Happy-path-only tests that miss branches and boundary values
  • Negative-path tests for invalid input and thrown errors
  • Async tests that finish before the promise or callback settles
  • Test isolation with setup and teardown hooks
  • Stubbing non-deterministic and external dependencies
  • Mock functions to verify callback and event-handler calls
  • Behaviour versus implementation-detail tests, false positives and negatives

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.

Go to Discord
  1. JavaScript Developer Checklist
  3. Asynchronous Programming

await inside forEach versus for...of loops

Explainer

Learn More

Practice Question

Keep going

Next conceptSynchronous dispatchEvent versus natively queued events

Checklist progress

0/233 (0%)

0 of 233 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.

Go to Discord
Close
  1. JavaScript Developer Checklist
  3. Asynchronous Programming
await inside forEach versus for...of loops

Explainer

Learn More

Practice Question

Keep going

Next conceptSynchronous dispatchEvent versus natively queued events

Explainer

Loops that call async functions behave very differently depending on which loop you use. Array.prototype.forEach() calls its callback once per element, but it does not wait for the promises an async callback returns. A for...of loop inside an async function pauses at each await before it moves to the next value. Knowing this difference lets you predict what code logs and choose the right fix.
Core information
  • JavaScript is single threaded, so only one function runs at a time. Asynchronous work, such as an API call or a timer, finishes later. A promise represents that eventual success or failure.
More details and nuances
  • forEach() returns undefined rather than a promise, so code after the loop has nothing to wait on. To make looped async work finish before later code runs, you have two options. Use for...of with await inside an async function to run the steps one after another, or start all the operations and pass their promises to Promise.all() to run them at the same time.

Explainer

Loops that call async functions behave very differently depending on which loop you use. Array.prototype.forEach() calls its callback once per element, but it does not wait for the promises an async callback returns. A for...of loop inside an async function pauses at each await before it moves to the next value. Knowing this difference lets you predict what code logs and choose the right fix.
Core information
  • JavaScript is single threaded, so only one function runs at a time. Asynchronous work, such as an API call or a timer, finishes later. A promise represents that eventual success or failure.
More details and nuances
  • forEach() returns undefined rather than a promise, so code after the loop has nothing to wait on. To make looped async work finish before later code runs, you have two options. Use for...of with await inside an async function to run the steps one after another, or start all the operations and pass their promises to Promise.all() to run them at the same time.