Salesforce Certified JavaScript Developer I Practice Exam

A developer declares a variable inside an if block using var and is surprised to find it accessible outside the block.

What explains this behavior?

1. Variables declared with var are function-scoped or globally-scoped, not block-scoped, so they are hoisted to the enclosing function
2. The if block creates a new function scope that leaks variables
3. The JavaScript engine optimizes variable access by promoting block variables
4. This is a browser bug that does not occur in Node.js

A developer writes a function that fetches user data from an API and needs to handle both successful responses and network errors gracefully.

What is the modern best practice for handling this asynchronous operation?

1. Use nested callbacks with an error-first pattern
2. Use synchronous XMLHttpRequest to simplify error handling
3. Use async/await with a try/catch block to handle both the resolved value and any errors from the fetch
4. Use setTimeout to poll for the API response

A developer needs to create a utility module that exports multiple helper functions for use across a JavaScript application.

What is the correct ES6 module syntax?

1. Attach the functions to the global window object
2. Use named exports (export function/const) in the module and named imports ({ functionName }) in consuming files
3. Define all functions as global variables in a script tag
4. Use CommonJS require() and module.exports exclusively

A developer has an array of order objects and needs to calculate total revenue from only the completed orders.

What method chain should the developer use?

1. Use array.filter() to select completed orders, then array.reduce() to sum the revenue values
2. Use a for loop with a running total and an if condition
3. Use array.find() to locate each completed order individually
4. Use array.map() to transform all orders, then sum the results

A developer creates objects with a constructor function and wants all instances to share a method without duplicating it in memory.

Where should the developer define this shared method?

1. Inside the constructor as this.method = function(){}
2. As a global function that accepts the object as a parameter
3. In a separate module that each instance imports independently
4. On the constructor function’s prototype object, so all instances inherit it through the prototype chain

A callback inside a class method loses access to the instance’s properties when passed to setTimeout.

What is causing this, and how should the developer fix it?

1. Class properties are private and cannot be accessed in callbacks
2. setTimeout does not support callback functions from classes
3. The this context is lost because setTimeout invokes the callback in the global context; use an arrow function, which lexically binds this
4. The callback executes before the class is fully initialized

A developer needs a web component that encapsulates its styling so external CSS can’t affect the component’s internal elements.

Which web standard should the developer use?

1. Shadow DOM to create an encapsulated DOM tree with scoped styling that prevents CSS leaking in or out
2. CSS modules with unique class-name prefixes
3. An iframe that isolates the component completely
4. Inline styles on every element within the component

A developer needs to run three asynchronous operations in parallel and wait for all of them to complete before proceeding.

Which Promise method should the developer use?

1. Use Promise.race() to get the fastest result
2. Use Promise.all() with an array of the three Promise-returning operations
3. Chain three .then() calls sequentially
4. Use Promise.any() to get the first successful result

A developer needs to write unit tests for a function that makes fetch API calls to an external service.

What testing approach should the developer use?

1. Make real API calls in the test and validate the response
2. Skip testing this function since it depends on an external service
3. Mock the fetch function using Jest’s mocking capabilities to return controlled responses, then test behavior across mock scenarios
4. Test only in production to get real API responses

A developer is implementing a debounce to limit how often a search API is called as a user types.

What JavaScript concept is essential for implementing debounce?

1. Synchronous function calls that block the event loop
2. Web Workers to process search queries in a separate thread
3. Event delegation on the parent container of the input field
4. Closures to maintain timer state across invocations, combined with clearTimeout/setTimeout to delay execution until typing pauses