JSA™ Exam Syllabus

Exam: JSA™ – Certified Associate JavaScript Programmer

Exam Version: JSA-41-01

Status: ACTIVE

The JSA exam consists of 40 single-select and multiple-select items that assess a candidate’s ability to work confidently with JavaScript objects, classes, built-in types and collections, and modern function/async patterns. Coverage centers on object manipulation, prototypal and class-based design, arrays and maps/sets, strings and numbers, dates and JSON, regular expressions, and asynchronous programming with callbacks, promises, and async/await.

Each item is worth a maximum of 10 points. After completion, the candidate’s raw score is normalized and presented as a percentage.

The exam is organized into four blocks aligned with core JavaScript programming practices. Block weights indicate the relative importance of each area in the overall exam.

JSA-41-01 Badge

The table below summarizes the distribution of exam items and their respective weight in the total exam score.

Block Number

Block Name

Number of Items

Weight

1

Classless Objects

11

25%


2

Classes & Class-Based Approach

7

23%


3

Built-in Objects

12

27%


4

Advanced Functions

10

25%


 

TOTAL

40

100%

Exam Syllabus

Last updated: September 22, 2025

Aligned with Exam JSA-41-01

Exam Syllabus Contents


Block 1: Classless Objects

11 objectives covered by the block → 11 exam items

1.1 Create Individual Objects (1)

Objective 1.1.1 Create objects using literals

  1. Declare objects with literal syntax and initialize fields.

1.2 Object Properties (1)

Objective 1.2.1 Explain and use object properties

  1. Add, modify, and delete properties safely.
  2. Work with nested properties and optional access patterns.

1.3 Dot vs. Bracket Notation (1)

Objective 1.3.1 Compare and contrast dot and bracket notations

  1. Prefer dot notation for standard identifiers.
  2. Use bracket notation for multi-word, dynamic, or computed keys.

1.4 Property Existence & Enumeration (1)

Objective 1.4.1 Test property existence and perform enumeration

  1. Check membership with the in operator and safe access.
  2. Iterate keys via for...in with filtering for own props.
  3. Use Object.keys(), Object.values(), Object.entries() for iteration.

1.5 Comparing Objects (1)

Objective 1.5.1 Compare and contrast objects

  1. Distinguish reference equality from deep structural comparison.
  2. Reason about identity vs. value equivalence.

1.6 Copying & Cloning (1)

Objective 1.6.1 Implement object copying mechanisms

  1. Copy references vs. clone values.
  2. Apply Object.assign() and spread for shallow clones.
  3. Understand deep cloning strategies and caveats.

1.7 Methods & this (1)

Objective 1.7.1 Explain and implement methods in code

  1. Store functions as properties and define methods in literals.
  2. Add methods to existing objects when appropriate.
  3. Use this correctly in method contexts.

1.8 Getters & Setters (1)

Objective 1.8.1 Explain and implement getters and setters

  1. Declare accessor properties with get and set.
  2. Use accessors to validate or compute fields.

1.9 Object Configuration (1)

Objective 1.9.1 Organize and configure objects and properties

  1. Set descriptors with Object.defineProperty().
  2. Control mutability via Object.preventExtensions(), Object.seal(), and Object.freeze().

1.10 Creating Classless Objects (1)

Objective 1.10.1 Demonstrate different ways to create classless objects

  1. Apply factory functions for custom initialization.
  2. Use constructor functions with new when needed.
  3. Create objects via Object.create() with explicit prototypes.

1.11 Prototypes (1)

Objective 1.11.1 Explain and apply the concept of prototypes

  1. Reason about prototype-based inheritance links.
  2. Recognize __proto__/[[Prototype]] and Function.prototype.
  3. Set prototypes via Object.setPrototypeOf() when required.

Block 2: Classes & Class-Based Approach

7 objectives covered by the block → 7 exam items

2.1 Class Declarations (1)

Objective 2.1.1 Design classes and implement class declarations

  1. Declare classes with class and define constructor, fields, and methods.
  2. Use class expressions and treat classes as first-class values.

2.2 Instantiation & Type Checks (1)

Objective 2.2.1 Create objects from classes

  1. Instantiate with new and verify relationships with instanceof.

2.3 Class Fields (1)

Objective 2.3.1 Explain and use class properties

  1. Initialize fields in the constructor or via class field syntax.

2.4 Accessors in Classes (1)

Objective 2.4.1 Create and implement getters and setters

  1. Expose computed/validated state with get/set in class bodies.

2.5 Inheritance (1)

Objective 2.5.1 Explain and apply the concept of inheritance

  1. Extend classes with extends and override members safely.
  2. Call parent logic via super in constructors and methods.

2.6 Static Members (1)

Objective 2.6.1 Explain and apply static members in code

  1. Define/access static methods and properties on the class itself.

2.7 Classes vs. Constructors (1)

Objective 2.7.1 Compare and contrast classes and constructors

  1. Relate class syntax to constructor functions and prototype methods.

Block 3: Built-in Objects

12 objectives covered by the block → 12 exam items

3.1 Number (1)

Objective 3.1.1 Explain and use the Number constructor

  1. Convert to/from numeric strings and formats.
  2. Use key static props/methods and formatting APIs.

3.2 String (1)

Objective 3.2.1 Explain and use the String constructor

  1. Treat strings as sequences; perform case, split, find/replace, pad/trim, and compare.

3.3 Date (1)

Objective 3.3.1 Explain and use the Date constructor

  1. Construct dates, read/write components, and measure elapsed time.
  2. Handle local time vs. UTC considerations.

3.4 Arrays (1)

Objective 3.4.1 Describe and implement the concept of arrays

  1. Create/merge; add/remove; slice/splice; spread and destructure.

3.5 Advanced Array Methods (1)

Objective 3.5.1 Explain and implement advanced array methods

  1. Apply find, every, some, filter, sort, map, reduce.

3.6 Set (1)

Objective 3.6.1 Explain, implement, and process Set collections

  1. Construct; add/has/delete/clear/size; iterate; spread.

3.7 Map (1)

Objective 3.7.1 Explain, implement, and process Map collections

  1. Construct; set/get/has/delete/clear/size; iterate key–value pairs.

3.8 Objects as Data Structures (1)

Objective 3.8.1 Implement objects as data structures

  1. Use plain objects as dictionaries; manage items and iterate entries.

3.9 JSON (1)

Objective 3.9.1 Use the JSON object to process data

  1. Serialize with JSON.stringify and parse with JSON.parse.

3.10 Math (1)

Objective 3.10.1 Use the Math object to perform operations

  1. Apply ceil, floor, round, random, min, max, abs, pow, log and trigonometry.

3.11 Regular Expressions (1)

Objective 3.11.1 Explain and apply the concept of regular expressions

  1. Declare via RegExp or literals; use test, exec, match, search, replace.

3.12 Extending Built-ins (1)

Objective 3.12.1 Explain and implement the concept of extending built-in types

  1. Add methods via prototypes responsibly; understand risks.

Block 4: Advanced Functions

10 objectives covered by the block → 10 exam items

4.1 Parameters & Arguments (1)

Objective 4.1.1 Organize and implement extended function parameter handling

  1. Use default values, rest parameters, and spread.
  2. Simulate named parameters with objects/destructuring.

4.2 Closures & IIFEs (1)

Objective 4.2.1 Explain and use closures and IIFEs

  1. Leverage closure over lexical environment.
  2. Apply Immediately Invoked Function Expressions.

4.3 Call Forwarding & Context (1)

Objective 4.3.1 Implement the mechanism for call forwarding

  1. Manage this and use call, apply, bind.

4.4 Function Decorators (1)

Objective 4.4.1 Implement the mechanism for decorating functions

  1. Compose wrappers/higher-order functions; pass/return functions.

4.5 Generators & Iterators (1)

Objective 4.5.1 Explain, create, and implement generators and iterators

  1. Define generator functions; iterate with for...of.
  2. Implement custom iterables/iterators.

4.6 Async with Callbacks (1)

Objective 4.6.1 Explain, organize, and handle asynchronous events using callbacks

  1. Model async flows and handle errors/callback conventions.

4.7 Promises (1)

Objective 4.7.1 Explain and apply the concept of promises

  1. Create promises and handle with then, catch, finally.

4.8 Promise Patterns (1)

Objective 4.8.1 Explain and apply advanced promise chaining techniques

  1. Chain sequences; use Promise.all, Promise.any, Promise.race.

4.9 async/await (1)

Objective 4.9.1 Use async and await to handle promises

  1. Write async functions; await results; manage errors with try/catch.

4.10 Network Requests (1)

Objective 4.10.1 Understand and implement asynchronous handling of network requests

  1. Retrieve data using XMLHttpRequest and the Fetch API with proper async handling.

Download JSA-41-01 Exam Syllabus in PDF

MQC Profile

A Minimally Qualified Candidate (MQC) for the JSA exam is an individual with solid foundational skills in core JavaScript. The candidate can model data with objects and prototypes, use classes and inheritance appropriately, manipulate built-in types and collections, and implement modern function and asynchronous patterns to solve well-defined problems.

The MQC understands object creation and configuration, enumeration and cloning strategies, accessor patterns, class syntax and static members, arrays and functional array methods, maps/sets, dates, numbers, strings, JSON, regular expressions, higher-order functions, generators/iterators, callbacks, promises, and async/await.

Block 1: Classless Objects

Minimum Coverage – the candidate can:

  • create, read, update, and delete properties; choose dot vs. bracket notation.
  • enumerate keys/values safely and apply shallow vs. deep cloning strategies.
  • declare methods, use this, define accessors, and configure mutability.
  • use factories, constructor functions, Object.create(), and prototypes.

Block 2: Classes & Class-Based Approach

Minimum Coverage – the candidate can:

  • declare classes with constructors, fields, methods, accessors, and statics.
  • instantiate with new, apply inheritance with extends, and use super.
  • relate classes to constructor/prototype mechanics.

Block 3: Built-in Objects

Minimum Coverage – the candidate can:

  • manipulate numbers, strings, dates, arrays (incl. functional methods), sets, and maps.
  • serialize/parse with JSON and use Math utilities effectively.
  • apply regular expressions via RegExp and string methods.
  • understand the implications of extending built-ins.

Block 4: Advanced Functions

Minimum Coverage – the candidate can:

  • use default/rest/spread and object-based “named” parameters.
  • leverage closures, IIFEs, context binding, and decorators/HOFs.
  • work with generators/iterators and the iterable protocol.
  • handle async with callbacks, promises, async/await, and network requests.

Passing Requirement

To pass the JSA exam, a candidate should achieve a cumulative average score of at least 70% across all exam blocks.