Career upgrade: Learn practical AI skills for better jobs and higher pay.
Level up
PracticeVideosBlogFlashcardsEspañol
All Practice Exams

100+ Free JavaScript Developer I Practice Questions

Pass your Salesforce Certified JavaScript Developer I exam on the first try — instant access, no signup required.

✓ No registration✓ No credit card✓ No hidden fees✓ Start practicing immediately
Salesforce does not publish pass rates Pass Rate
100+ Questions
100% Free
1 / 100
Question 1
Score: 0/0

What does `require()` do in Node.js?

A
B
C
D
to track
Same family resources

Explore More Salesforce Certifications

Continue into nearby exams from the same family. Each card keeps practice questions, study guides, flashcards, videos, and articles in one place.

Salesforce Certified Administrator

Practice QuestionsStudy GuideCheat SheetFlashcards1 video2 blogs

Salesforce Agentforce

Practice Questions

Salesforce Certified Advanced Administrator

Practice Questions

Salesforce Platform App Builder

Practice Questions

Salesforce Platform Developer I

Practice Questions

Salesforce Service Cloud Consultant

Practice Questions

More From This Family

Videos and articles for deeper review.

VideoFREE Salesforce Admin Exam Guide 2026: Pass on First TryArticleFREE Salesforce Admin Exam Guide 2026: Pass on First Try28 min readArticleSalesforce Admin Salary & Is It Worth It in 2026? (Free)13 min read
2026 Statistics

Key Facts: JavaScript Developer I Exam

65%

Passing Score

Salesforce

60 + 5

Scored + Unscored Questions

Salesforce

105 min

Exam Duration

Salesforce

$200

Exam Fee

Salesforce

48%

Objects + Variables Weight

Top two domains combined

ES6+

JavaScript Standard Tested

Salesforce exam guide

The Salesforce JavaScript Developer I exam has 60 scored questions plus 5 unscored in 105 minutes with a 65% passing score. Objects/Functions/Classes (25%) and Variables/Data Types/Collections (23%) are the two heaviest domains at 48% combined. Exam fee is $200 with a $100 retake fee.

Sample JavaScript Developer I Practice Questions

Try these sample questions to test your JavaScript Developer I exam readiness. Each question includes a detailed explanation. Start the interactive quiz above for the full 100+ question experience with AI tutoring.

1What is the output of the following code? ```js var x = 1; function foo() { console.log(x); var x = 2; } foo(); ```
A.1
B.2
C.undefined
D.ReferenceError
Explanation: Variable declarations with `var` are hoisted to the top of their containing function, but their assignments are not. Inside `foo`, `var x` is hoisted so `x` exists as `undefined` when `console.log(x)` runs, before the assignment `x = 2` is reached.
2Which of the following correctly describes the difference between `let` and `var`?
A.let is function-scoped; var is block-scoped
B.let is block-scoped; var is function-scoped
C.Both let and var are block-scoped
D.Both let and var are function-scoped
Explanation: `var` declarations are scoped to the nearest enclosing function (or global if none), while `let` declarations are scoped to the nearest enclosing block (e.g., `if`, `for`, or `{}`). This means a `let` variable declared inside a loop body is not accessible outside the loop block.
3What is the output of this code? ```js const arr = [1, 2, 3]; arr.push(4); console.log(arr.length); ```
A.3
B.4
C.TypeError
D.undefined
Explanation: `const` prevents reassignment of the variable binding, but it does not make the object or array immutable. Mutating methods like `push` are perfectly valid on a `const` array, so `arr` now has four elements and `arr.length` is 4.
4What does the following destructuring assignment produce for `b`? ```js const [a, b = 10, c] = [1, undefined, 3]; console.log(b); ```
A.undefined
B.10
C.1
D.null
Explanation: Destructuring default values are applied when the extracted value is `undefined`. Since the second element of the array is `undefined`, the default value `10` is used for `b`.
5What is the result of `typeof null` in JavaScript?
A.null
B.undefined
C.object
D.string
Explanation: `typeof null` returns `'object'` — this is a well-known historical bug in JavaScript that has been kept for backward compatibility. To reliably check for `null`, use a strict equality check: `value === null`.
6Given the code below, what is logged? ```js const map = new Map(); map.set('a', 1); map.set('b', 2); console.log(map.size); ```
A.undefined
B.2
C.1
D.NaN
Explanation: `Map` uses a `.size` property (not `.length`) that reflects the number of key-value pairs. After two `set` calls, `map.size` is 2.
7Which statement about `Set` is correct?
A.A Set can contain duplicate primitive values
B.A Set maintains insertion order and does not allow duplicate values
C.A Set is similar to a WeakMap and only holds object references
D.A Set automatically sorts values in ascending order
Explanation: A `Set` is a collection of unique values that maintains insertion order. Attempting to add a duplicate value is silently ignored. It can hold any type of value, including primitives and objects.
8What is the output? ```js const obj = { a: 1, b: 2, c: 3 }; const { a, ...rest } = obj; console.log(rest); ```
A.{ a: 1 }
B.{ b: 2, c: 3 }
C.{ a: 1, b: 2, c: 3 }
D.undefined
Explanation: The rest syntax in object destructuring collects all remaining enumerable own properties not already destructured. After extracting `a`, the `rest` variable contains `{ b: 2, c: 3 }`.
9What does `Number('') === 0` evaluate to?
A.false
B.true
C.TypeError
D.NaN
Explanation: When an empty string is converted to a Number, JavaScript returns `0`. Therefore `Number('') === 0` is `true`. This is an important type coercion behavior to know.
10Which of the following creates a shallow copy of an array `arr`?
A.arr.clone()
B.[...arr]
C.arr.copy()
D.Object.freeze(arr)
Explanation: The spread syntax `[...arr]` creates a new array containing all elements of `arr`, producing a shallow copy. Changes to the copy's top-level elements do not affect the original, though nested objects are still shared references.

About the JavaScript Developer I Exam

The Salesforce Certified JavaScript Developer I exam validates expertise in JavaScript programming for the Salesforce platform, including Lightning Web Components and server-side Node.js patterns. The exam covers Variables/Data Types/Collections (23%), Objects/Functions/Classes (25%), Browser/Events (17%), Testing (15%), Server-side JavaScript (13%), and Debugging/Error Handling (7%).

Questions

60 scored questions

Time Limit

105 minutes

Passing Score

65%

Exam Fee

$200 (Webassessor / Kryterion)

JavaScript Developer I Exam Content Outline

25%

Objects, Functions, and Classes

Prototypal inheritance, ES6 classes, closures, higher-order functions, this context, call/apply/bind, factory patterns, and object composition

23%

Variables, Data Types, and Collections

var/let/const scoping, primitive types, type coercion, arrays, objects, Map, Set, destructuring, spread/rest operators, and Symbol

17%

Browser and Events

DOM selection and manipulation, event listeners, event bubbling/capturing/delegation, Promises, async/await, fetch API, localStorage/sessionStorage

15%

Testing

Unit testing fundamentals, Jest test runner, describe/test/expect syntax, mocks, stubs, spies, TDD workflow, and code coverage

13%

Server-Side JavaScript

Node.js event loop, CommonJS vs ES Modules, npm package management, http module, Express middleware pattern, file system, and environment variables

7%

Debugging and Error Handling

Browser and Node.js DevTools, try/catch/finally, Error types (TypeError, ReferenceError, SyntaxError), error propagation, and async error handling

How to Pass the JavaScript Developer I Exam

What You Need to Know

  • Passing score: 65%
  • Exam length: 60 questions
  • Time limit: 105 minutes
  • Exam fee: $200

Keys to Passing

  • Complete 500+ practice questions
  • Score 80%+ consistently before scheduling
  • Focus on highest-weighted sections
  • Use our AI tutor for tough concepts

JavaScript Developer I Study Tips from Top Performers

1Master Objects/Functions/Classes (25%) — understand prototypal inheritance, closure patterns, ES6 class syntax, and this binding across call/apply/bind
2Know your data types and coercion (23%) — understand == vs ===, typeof, truthiness, and when coercion occurs
3Practice async JavaScript thoroughly — Promises, async/await, and Promise.all/race are heavily tested in the Browser/Events domain (17%)
4Learn Jest testing patterns (15%) — write describe/test/expect blocks, mock modules, use spies, and understand what code coverage measures
5Study Node.js fundamentals (13%) — know CommonJS require vs ES Module import/export, npm scripts, and the event loop
6Practice debugging techniques — use console.log, breakpoints, and DevTools; understand the Error constructor and propagation
7Build real projects: write closures, create classes, test with Jest, and build a small Express server

Frequently Asked Questions

What is the Salesforce JavaScript Developer I exam?

The Salesforce Certified JavaScript Developer I exam validates JavaScript programming skills for the Salesforce platform. It covers ES6+ language features, browser APIs, Node.js, testing with Jest, and debugging. The exam has 60 scored questions plus 5 unscored in 105 minutes with a 65% passing score.

How many questions are on the JavaScript Developer I exam?

The JavaScript Developer I exam has 60 scored questions plus 5 unscored pretest questions (65 total). You have 105 minutes to complete the exam. Unscored questions are not identified and are used to evaluate potential new exam questions.

What JavaScript topics does the exam cover?

The exam covers six domains: Objects/Functions/Classes (25%), Variables/Data Types/Collections (23%), Browser/Events (17%), Testing (15%), Server-side JavaScript/Node.js (13%), and Debugging/Error Handling (7%). ES6+ features, Promises, async/await, and Jest testing are heavily represented.

How hard is the Salesforce JavaScript Developer I exam?

The exam is considered moderate to challenging. It requires solid JavaScript programming knowledge including ES6+ syntax, prototypal inheritance, async patterns, Node.js basics, and Jest testing. Candidates with 1-2 years of JavaScript development experience and LWC familiarity typically pass with proper preparation.

How should I prepare for the JavaScript Developer I exam?

Plan for 80-130 hours over 8-12 weeks. Focus on Objects/Functions/Classes (25%) and Variables/Data Types/Collections (23%), which together make up 48% of the exam. Build real JavaScript projects, write Jest tests, and practice Node.js module patterns. Complete 100+ practice questions and score 80%+ before scheduling.

What jobs can I get with Salesforce JavaScript Developer I certification?

This certification supports roles including Salesforce LWC Developer ($90,000-130,000), Front-End Salesforce Developer, Salesforce Platform Developer, Full-Stack Salesforce Engineer, and JavaScript Integration Specialist. It pairs well with Platform Developer I for a full Salesforce development credential set.