Salesforce JavaScript Developer

Real programs spend their time moving data through arrays and objects. You use array methods to transform collections, work with maps and sets, and convert between objects and JSON.

• Array basics and mutation against copy
• map, filter and reduce
• Searching, sorting and flattening
• Map and Set
• Destructuring and the spread operator
• JSON.parse and JSON.stringify

You build A data transformer that reshapes a JSON payload using array methods.

Functions are the unit of reuse in JavaScript, and scope decides what they can see. You write functions in several forms, trace scope and closures, and control the value of this.

• Function declarations, expressions and arrows
• Parameters, defaults and rest
• Scope and the scope chain
• Closures and their uses
• How this is determined
• call, apply and bind
• Higher-order functions

You build A small library of reusable functions built with closures and higher-order patterns.

Objects in JavaScript inherit through prototypes, not classes. You build objects, control their properties, and follow the prototype chain to see where a method comes from.

• Object literals and property access
• Property descriptors and freezing
• Computed and shorthand properties
• The prototype chain
• Constructor functions and Object.create
• Copying objects: shallow and deep

You build An object model built with prototypes, with its chain traced in the console.

Classes and modules organize larger programs. You write classes with inheritance and private fields, and split code into ES modules and CommonJS modules with clear exports.

• Class syntax and constructors
• Inheritance and super
• Static and private members
• Getters and setters
• ES modules: import and export
• CommonJS modules compared
• Choosing a design for a requirement

You build A modular program with classes, split across several files.

In the browser, the DOM is the program’s window on the page. You select and change elements, handle events and understand propagation, and use delegation to keep handlers manageable.

• Selecting and creating elements
• Changing content, attributes and styles
• Event listeners and the event object
• Capturing, bubbling and stopping propagation
• Event delegation
• Forms and input events

You build An interactive page that uses event delegation to manage a dynamic list.

Browsers offer much more than the DOM. You use fetch, storage and timers, and investigate behavior with the elements, network and sources panels of the developer tools.

• fetch and working with responses
• Local storage and session storage
• Timers and animation frames
• The elements and styles panels
• The network panel
• The sources panel and the console

You build A page that loads and caches remote data, investigated with developer tools.

Code fails, and what matters is how it fails. You handle errors with try and catch, throw useful ones, and debug with the console and breakpoints rather than guesswork.

• Error types and the error object
• try, catch and finally
• Throwing custom errors
• Console methods beyond log
• Breakpoints and stepping
• Reading a stack trace

You build A script with deliberate faults, each located and fixed with the debugger.

Nothing in the browser waits, so order of execution has to be understood. You use callbacks, promises and async functions, and predict output from the event loop and microtask queue.

• Callbacks and callback hell
• Promises and chaining
• async and await
• Promise.all and its relatives
• The call stack and event loop
• Microtasks against macrotasks
• Handling errors in asynchronous code

You build A set of async scripts whose output order is predicted before running.

Salesforce interfaces run on modern JavaScript. You see how components use modules, classes, decorators and events, and how the same language skills carry into the platform.

• A component as a JavaScript class
• Modules and imports in components
• Decorators and reactive properties
• Events between components
• Calling server methods asynchronously
• Debugging component code in the browser

You build A small Lightning Web Component that uses classes, events and async calls.

JavaScript also runs on servers and in tools. You choose a suitable Node.js approach for a task, use core modules and the command line, and manage dependencies with a package manager.

• What Node.js is and how it runs code
• Core modules: fs, path and http
• Reading arguments and environment variables
• package.json, scripts and dependencies
• Semantic versioning and lock files
• Choosing a Node.js tool for a scenario

You build A command-line tool that reads files and calls a service, with managed dependencies.

A test is only useful if it can fail. You write unit tests, find where a weak test lets a bug through, and revise it so that it checks behavior.

• Unit tests, assertions and structure
• Testing pure functions
• Mocks and spies
• Testing asynchronous code
• Finding an ineffective test
• Revising a test to catch the bug

You build A test suite for a module, including a weak test found and fixed.

Build one small program that uses data handling, functions, classes, events, asynchronous calls and a Node.js service. You test it, debug it and explain your design choices.

• Scoping a small full-stack task
• Writing the data and function layer
• Building the browser interface
• Adding the Node.js service and tests
• Reviewing the code for clarity

You build A working program with a browser interface, a Node.js service and tests.