All Practice Exams

100+ Free Certified Associate JavaScript Programmer Practice Questions

Pass your JSA - Certified Associate JavaScript Programmer (Exam JSA-41-01) exam on the first try — instant access, no signup required.

✓ No registration✓ No credit card✓ No hidden fees✓ Start practicing immediately
100+ Questions
100% Free
1 / 100
Question 1
Score: 0/0

What does [1, 2, 3, 4].slice(1, 3) return?

A
B
C
D
to track
Same family resources

Explore More JavaScript Programming Certifications

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

2026 Statistics

Key Facts: Certified Associate JavaScript Programmer Exam

$295

Exam Fee (USD, single voucher)

OpenEDG JS Institute

70%

Passing Average Across Blocks

OpenEDG JS Institute

40 items

Single- and Multiple-Select Questions

OpenEDG JS Institute syllabus

65 min

Total Appointment Time

OpenEDG JS Institute

4 blocks

Objects 25%, Classes 23%, Built-ins 27%, Functions 25%

OpenEDG JS Institute syllabus

Lifetime

Credential Validity (no renewal)

OpenEDG JS Institute

The OpenEDG JS Institute lists JSA - Certified Associate JavaScript Programmer (exam JSA-41-01) as an associate-level credential with a $295 USD fee and a 70% passing average across all blocks. The exam presents 40 single-select and multiple-select items in 65 minutes through Pearson VUE. The four blocks are Classless Objects (25%), Classes and the Class-Based Approach (23%), Built-in Objects (27%), and Advanced Functions (25%). The certification has lifetime validity and no renewal requirement.

Sample Certified Associate JavaScript Programmer Practice Questions

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

1Which expression creates an object using the literal syntax with two properties, name and age?
A.const user = Object('name', 'Ada', 'age', 36);
B.const user = { name: 'Ada', age: 36 };
C.const user = new Object[name: 'Ada', age: 36];
D.const user = [ name: 'Ada', age: 36 ];
Explanation: An object literal uses curly braces with comma-separated key: value pairs, so { name: 'Ada', age: 36 } is the correct literal form. This is the most direct and idiomatic way to create an individual object in JavaScript.
2Given const obj = { 'first-name': 'Ada' };, which statement correctly reads the property?
A.obj.first-name
B.obj.'first-name'
C.obj['first-name']
D.obj(first-name)
Explanation: A key that contains a hyphen is not a valid identifier, so dot notation cannot be used. Bracket notation with the key as a string, obj['first-name'], is required for multi-word or non-identifier keys.
3What does the following code log? const o = { a: 1 }; delete o.a; console.log(o.a);
A.1
B.null
C.undefined
D.ReferenceError
Explanation: The delete operator removes the property a from the object. Accessing a property that no longer exists (or never existed) on an object returns undefined, not an error.
4Which expression safely reads street when the chain may be missing, returning undefined instead of throwing? const data = {};
A.data.address.street
B.data?.address?.street
C.data['address']['street']
D.data.address && street
Explanation: Optional chaining (?.) short-circuits and returns undefined if a reference in the chain is null or undefined, so data?.address?.street is safe when address is absent. The other dotted/bracket forms throw a TypeError because they try to read street on undefined.
5What is the result of the following expression? const car = { brand: 'Fiat' }; console.log('brand' in car, 'model' in car);
A.true false
B.false true
C.true true
D.false false
Explanation: The in operator returns true when the named property exists on the object (or its prototype chain) and false otherwise. brand exists so it is true, while model does not exist so it is false.
6Which method returns an array of a plain object's own enumerable property names?
A.Object.values(obj)
B.Object.entries(obj)
C.Object.keys(obj)
D.Object.getOwnPropertyDescriptors(obj)
Explanation: Object.keys(obj) returns an array containing the object's own enumerable property names (keys) as strings. It is the standard way to obtain just the key list for iteration or counting.
7What does this code log? const a = { x: 1 }; const b = { x: 1 }; console.log(a === b);
A.true
B.false
C.undefined
D.TypeError
Explanation: Objects are compared by reference identity, not by structural value. Although a and b have identical contents, they are two distinct objects in memory, so a === b is false.
8After the following code runs, what does original.nested.value equal? const original = { nested: { value: 1 } }; const copy = { ...original }; copy.nested.value = 99;
A.1
B.99
C.undefined
D.NaN
Explanation: The spread operator performs a shallow copy, so copy.nested and original.nested reference the same inner object. Mutating copy.nested.value therefore also changes original.nested.value to 99.
9Which call merges the properties of source into target, mutating target and returning it?
A.Object.merge(target, source)
B.Object.assign(target, source)
C.Object.combine(target, source)
D.Object.copy(target, source)
Explanation: Object.assign(target, ...sources) copies own enumerable properties from the source objects into the target, mutating and returning the target. It is commonly used for shallow merges and shallow clones.
10What does the following log? const counter = { count: 5, increment() { this.count++; } }; counter.increment(); console.log(counter.count);
A.5
B.6
C.NaN
D.undefined
Explanation: When increment is called as counter.increment(), this refers to the counter object, so this.count++ raises count from 5 to 6. Method shorthand in object literals defines a function stored as a property.

About the Certified Associate JavaScript Programmer Exam

The JSA - Certified Associate JavaScript Programmer credential (current exam code JSA-41-01) validates intermediate JavaScript proficiency in object-oriented analysis, design, and programming, plus the advanced use of functions. The exam contains 40 single-select and multiple-select items delivered through OpenEDG Testing Service and Pearson VUE, and candidates must reach a 70% cumulative average across four blocks to pass. The blueprint spans classless objects (literals, factories, constructor functions, Object.create, prototypes), classes and inheritance (extends, super, static and private members), built-in objects (Number, String, Date, Math, JSON, RegExp, arrays, Map, Set), and advanced functions (closures, higher-order functions, generators, callbacks, promises, and async/await). The credential sits above the JSE entry level and has lifetime validity with no renewal.

Questions

40 scored questions

Time Limit

65 minutes (60-minute exam plus 5-minute NDA and tutorial)

Passing Score

70% cumulative average across all blocks

Exam Fee

$295 (OpenEDG JS Institute)

Certified Associate JavaScript Programmer Exam Content Outline

25%

Classless Objects

Create individual objects with literals; add, modify, and delete properties using dot and bracket notation; check existence with in and enumerate with Object.keys/values/entries; compare, copy, and deep-clone objects; define getters/setters; configure mutability with defineProperty, preventExtensions, seal, and freeze; and build classless objects with factories, constructor functions, Object.create, and prototypes via setPrototypeOf.

23%

Classes and the Class-Based Approach

Declare classes and class expressions; instantiate with new and verify with instanceof; initialize class fields and private fields; expose computed state with get and set accessors; implement inheritance with extends and call parent logic with super; define static methods and properties; and relate class syntax to constructor functions and prototype methods.

27%

Built-in Objects

Work with Number formatting and conversion; String operations like slice, split, replace, pad, and trim; Date construction and elapsed-time measurement; Arrays with slice/splice/spread and functional methods find, every, some, filter, sort, map, and reduce; Set and Map collections; objects as dictionaries; JSON.stringify and JSON.parse; Math methods; and regular expressions with test, exec, match, search, and replace.

25%

Advanced Functions

Use default values, rest parameters, and spread; leverage closures and IIFEs over the lexical environment; manage this with call, apply, and bind; compose decorators and higher-order functions; define generators and custom iterators; and handle asynchronous flows with callbacks, promises (then/catch/finally, all/any/race), async/await with try/catch, and network requests via XMLHttpRequest and the Fetch API.

How to Pass the Certified Associate JavaScript Programmer Exam

What You Need to Know

  • Passing score: 70% cumulative average across all blocks
  • Exam length: 40 questions
  • Time limit: 65 minutes (60-minute exam plus 5-minute NDA and tutorial)
  • Exam fee: $295

Keys to Passing

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

Certified Associate JavaScript Programmer Study Tips from Top Performers

1Write and run small snippets that trace the prototype chain with Object.create, Object.getPrototypeOf, and Object.setPrototypeOf; the exam tests how property lookup walks the chain.
2Practice closures and this binding: predict outputs for IIFEs, returned closures, and detached methods, and know how call, apply, and bind change context.
3Master functional array methods (map, filter, reduce, find, every, some, sort) and remember that default sort is lexicographic unless you supply a numeric comparator.
4Be precise about Object configuration: know exactly what preventExtensions, seal, and freeze allow versus block, and how non-strict mode silently ignores invalid writes.
5Drill asynchronous ordering: synchronous code, then microtasks (promise callbacks and code after await) run before macrotasks; trace mixed console.log and await examples.
6Review regular expression methods and flags: test and exec on RegExp, plus match, search, and replace on strings, and how the g flag changes replace and match results.

Frequently Asked Questions

What are the current exam facts for JSA-41-01?

The OpenEDG JS Institute lists JSA-41-01 as an associate-level exam with a $295 USD fee and a 70% cumulative passing average across all blocks, delivered through Pearson VUE. It presents 40 single-select and multiple-select items, with a total appointment time of about 65 minutes.

What does the JSA exam measure?

JSA validates intermediate JavaScript object-oriented analysis, design, and programming, plus advanced functions. The four blocks are Classless Objects, Classes and the Class-Based Approach, Built-in Objects, and Advanced Functions, covering prototypes, classes, collections, regular expressions, closures, and asynchronous code.

Which block carries the most weight on the JSA exam?

Built-in Objects is the heaviest block at 27%, covering Number, String, Date, Math, JSON, RegExp, arrays and functional array methods, and the Set and Map collections. Classless Objects (25%) and Advanced Functions (25%) follow closely.

Is the JSA harder than the JSE entry-level exam?

Yes. JSA - Certified Associate sits above the JSE - Certified Entry-Level exam, adding object-oriented design, prototypes, classes, regular expressions, generators, and asynchronous programming with promises and async/await. JSE focuses on JavaScript fundamentals and control flow.

How long is the JSA credential valid?

The JSA certification has lifetime validity. Unlike many vendor certifications, it does not expire and there is no renewal requirement once you pass the JSA-41-01 exam.

What is the best way to prepare for JSA?

Run real code: trace prototype chains, predict closure and this behavior, and reason about promise and async/await ordering in the microtask queue. Drill array methods, Map/Set, regular expressions, and Object configuration (freeze, seal, defineProperty) until each output is predictable.