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

Given a scenario, write code to create variables and initialize them correctly

0/12

  • 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

Given a business requirement, utilize strings, numbers, and dates effectively

0/17

  • 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

Given a scenario or example, demonstrate awareness of type coercion and its effects

0/8

  • 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

Given a specific scenario, distinguish truthy or falsey evaluations

0/7

  • 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

Given a list of data, demonstrate data manipulation with arrays

0/16

Array creation with literals, the Array constructor and Array.from

Learn this concept
Unseen

Array length, index assignment and empty slots

Learn this concept
Unseen

Adding and removing elements at either end of an array

Learn this concept
Unseen

splice for inserting, removing and replacing elements

Learn this concept
Unseen

for...of versus for...in versus forEach over arrays

Learn this concept
Unseen

forEach versus map for transforming elements

Learn this concept
Unseen

filter predicates and the elements they keep

Learn this concept
Unseen

Searching arrays and testing elements against a condition

Learn this concept
Unseen

reduce accumulators and the initial value

Learn this concept
Unseen

Chaining filter, map and reduce over a list of objects

Learn this concept
Unseen

Converting between arrays and strings

Learn this concept
Unseen

Default array sort order versus comparator functions

Learn this concept
Unseen

Mutating versus non-mutating array methods

Learn this concept
Unseen

Copying and merging arrays versus sharing a reference

Learn this concept
Unseen

Nested arrays and flattening

Learn this concept
Unseen

Set and Map keyed collections for deduplication and lookup

Learn this concept
Unseen

Given a JSON response, demonstrate how to operate the JSON object

0/8

  • 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
  • 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
  • Call stack, task queue and event loop roles in the runtime
  • Synchronous statements versus zero-delay setTimeout callbacks
  • Multiple timer ordering and delays as minimum waits
  • setTimeout callbacks inside loops with var versus let
  • Promise microtasks versus setTimeout macrotasks
  • Promise executor timing versus then handler timing
  • Async function execution before and after await
  • Tasks and microtasks scheduled from inside other callbacks
  • await inside forEach versus for...of loops
  • Synchronous dispatchEvent versus natively queued events
  • 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. 662 members and growing.

Go to Discord
  1. JavaScript Developer Checklist
  3. Variables, Types, and Collections

Chaining filter, map and reduce over a list of objects

Explainer

Learn More

Practice Question

Keep going

Next conceptConverting between arrays and strings

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. 662 members and growing.

Go to Discord
Close
  1. JavaScript Developer Checklist
  3. Variables, Types, and Collections
Chaining filter, map and reduce over a list of objects

Explainer

Learn More

Practice Question

Keep going

Next conceptConverting between arrays and strings

Explainer

filter(), map() and reduce() are array methods that each run a function you pass in (a callback) on the elements of an array. filter() and map() each return a new array, so you can call the next method straight on the result, and reduce() collapses an array into one value, such as a total. Chaining them lets you pick items from a list of objects, reshape them, and combine them in one expression.
Core information
  • Each method calls your callback once for each element that has an assigned value. For filter() and map(), the callback receives the current element, its index, and the array the method was called on.
More details and nuances
  • When you reduce() a list of objects straight to a number, you must pass an initialValue so every item passes through your callback. Without it, the first object itself becomes the accumulator and is used as-is. The fix is the second argument: [{ x: 1 }, { x: 2 }, { x: 3 }].reduce((acc, cur) => acc + cur.x, 0) returns 6.

Explainer

filter(), map() and reduce() are array methods that each run a function you pass in (a callback) on the elements of an array. filter() and map() each return a new array, so you can call the next method straight on the result, and reduce() collapses an array into one value, such as a total. Chaining them lets you pick items from a list of objects, reshape them, and combine them in one expression.
Core information
  • Each method calls your callback once for each element that has an assigned value. For filter() and map(), the callback receives the current element, its index, and the array the method was called on.
More details and nuances
  • When you reduce() a list of objects straight to a number, you must pass an initialValue so every item passes through your callback. Without it, the first object itself becomes the accumulator and is used as-is. The fix is the second argument: [{ x: 1 }, { x: 2 }, { x: 3 }].reduce((acc, cur) => acc + cur.x, 0) returns 6.