Salesforce Certified JavaScript Developer I Exam Guide.

The Salesforce Certified JavaScript Developer I is intended for individuals who have knowledge, skills, and experience developing front-end and/or back-end JavaScript applications for the web stack.

1. About the Salesforce JavaScript Developer I Certification Exam

Salesforce Certified JavaScript Developer I exam consists of two parts, the Lightning Web Components Specialist Superbadge and the JavaScript Developer I proctored multiple-choice exam. These two credentials can be earned in any sequence. The combination of both of these credentials earns the Salesforce Certified JavaScript Developer I Certification.

  • Content: 60 multiple-choice/multiple-select questions
  • Time allotted to complete the exam: 105 minutes
  • Passing score: 65% (39 out of 60 Questions)
  • Registration fee: USD 200, plus applicable taxes as required per local law
  • Reschedule fee: USD 100, plus applicable taxes as required per local law
  • Prerequisite: None

2. Exam Outline

Variables, Types, and Collections: 23%

  • Given a scenario, write code to create variables and initialize them correctly.
  • Given a business requirement, utilize strings, numbers, and dates effectively.
  • Given a scenario or example, demonstrate awareness of type coercion and its effects.
  • Given a specific scenario, distinguish truthy or falsey evaluations
  • Given a list of data, demonstrate data manipulation with arrays.
  • Given a JSON response, demonstrate how to operate the JSON object.

Objects, Functions, and Classes: 25%

  • Given a business requirement, locate the best function implementation.
  • Given a business requirement, apply fundamentals of object implementation to solve the business requirement.
  • Given a business requirement, apply fundamentals of class implementation to solve the business requirement.
  • Given a JavaScript module, give examples of how to use the module.
  • Given a JavaScript decorator, give examples of how to use the decorator.
  • Given a block of code, analyze the variable scope and the execution flow.

Browser and Events: 17%

  • Given a business requirement, utilize Events, event handlers and propagation.
  • Given a business requirement, evaluate and manipulate the DOM.
  • Given a scenario, utilize the Browser Dev Tools to investigate code behavior. 
  • Given a scenario and requirements, utilize browser specific APIs.

Debugging and Error Handling: 7%

  • Given a scenario, handle errors properly.
  • Given code to be debugged, use the console and breakpoints.

Asynchronous Programming: 13%

  • Given a scenario, apply asynchronous programming concepts.
  • Given a scenario, use event loop and event monitor or determine loop outcomes.

Server Side JavaScript: 8%

  • Given a scenario and requirements, infer which Node.js implementation is a good solution.
  • Given a scenario and requirements, infer which Node.js CLI command is a good solution.
  • Know the core Node.js modules and given requirements, infer which Node.js library/framework is a good solution.
  • Given a scenario and requirements, distinguish which Node.Js Package Management solution is the most fitting.

Testing: 7%

  • With a block of code and the associated Unit Test, determine where the test is ineffective and modify it to make it more effective.

3. Exam Guide

4. JavaScript Developer Certification Trail

5. JavaScript Developer Certification Trailmix

6. Important Topics for JavaScript Developer Exam

6.1 Variables, Types, and Collections: 23% (14 Questions)

  • JavaScript Data Types
    • Primitive values
      • Boolean
      • Null
      • Undefined
      • Number
      • BigInt
      • String
      • Symbol
    • Objects (collection of properties)
// Boolean
let amIHappy = true;

// Number
let currentYear  = 2021;

// String
let blogName = 'Forcepective.com';

// Array
let carArray = ['Honda', 'Toyota', 'BMW'];

// Object
let myCar = {name : 'Honda', make : 'CRV'}
  • Array Methods
// Create an Array
let cars = ['Honda', 'Toyota', 'BMW']

console.log(cars.length)
// 3

//Access an Array item using the index position
let firstCar = cars[0]
// Honda

//Loop over an Array
cars.forEach(function(item, index, array) {
  console.log(item, index)
})
// Honda 0
// Totota 1
// BMW 2

//Remove an item from the beginning of an Array
let firstCar = cars.shift() // remove Honda from the front
// ["Toyota", "BMW"]

//Add an item to the beginning of an Array
let newLength = cars.unshift('Ford') // adds Ford to the front
// ["Ford", "Toyota", "BMW"]

//Remove an item from the end of an Array
let lastCar = cars.pop() // remove BMW from the end
// ["Ford", "Toyota"]

//Add an item to the end of an Array
let lastCar = cars.push('Audi') // adds Audi to the end
// ["Ford", "Toyota", "Audi"]

// Find the index of an item in the Array
let toyotaPosition = cars.indexOf('Toyota');
// 1

// Remove an item by index position
let removedCar = cars.splice(toyotaPosition, 1);
// ["Ford", "Audi"]

// Copy an Array
let carsCopy = cars.slice();
// ["Ford", "Audi"]
  • String Methods
  • Date Methods
  • Type coercion – Automatic or implicit conversion of values from one data type to another (such as strings to numbers). Type conversion is similar to type coercion because they both convert values from one data type to another with one key difference — type coercion is implicit whereas type conversion can be either implicit or explicit.

Example:

const value1 = '1';
const value2 = 2;
let sum = value1 + value2;

console.log(sum);

In the above example, JavaScript has coerced the 2 from a number into a string and then concatenated the two values together, resulting in a string of 12.

  • Truthy or Falsey evaluations
  • JSON object.

6.2 Objects, Functions, and Classes: 25% (15 Questions)

  • Functions – reusable blocks of code that you can write once and run again and again, saving the need to keep repeating code all the time. In JavaScript functions are essentially special objects. As objects, they are first-class members of JavaScript. They can be assigned as the values of variables, passed into other functions as parameters, and returned from functions. 
/* Function Declaration */
function greeting() {
  alert('How are you today?');
}

/* Function Expressions */
let myCar = function () {
  alert('Honda');
}
  • Objects
  • Class
  • Modules
  • JavaScript decorator
  • Variable scope
  • Execution flow

6.3 Browser and Events: 17% (10 Questions)

  • Events – code structures that listen for activity in the browser, and run code in response. An example is handling the click event, which is fired by the browser when you click on something with your mouse. The constructs that listen out for the event happening are called event listeners, and the blocks of code that run in response to the event firing are called event handlers.
document.querySelector('ClickMe').onclick = function() {
    alert('Welcome to Forcepective.com!');
}
  • Event handlers
  • Event propagation
  • DOM
  • Browser Dev Tools  
  • Browser specific APIs

6.4 Debugging and Error Handling: 7% (4 Questions)

  • Error Handling
  • Console Methods – The console object provides access to the browser’s debugging console. The console object can be accessed from any global object. Some of the key console methods are:
/* Outputting text to the console */
console.log("Some Message");
console.info("Some Message");
console.warn("Some Message");
console.error("Some Message");

/* Using groups in console */
console.group("First group");
console.log("In the first group");
console.groupEnd();

/* Timers */
console.time("answer time");
alert("Click to continue");
console.timeLog("answer time");
alert("Do a bunch of other stuff...");
console.timeEnd("answer time");

/* Stack Trace */
console.trace();
  • Breakpoint

6.5 Asynchronous Programming: 13% (8 Questions)

  • Asynchronous JavaScript

6.6 Server Side JavaScript: 8% (5 Questions)

  • Node.js
  • Node.Js Package Management

6.7 Testing: 7% (4 Questions)

  • JavaScript Unit Testing

Recommended Articles

 

Tags:

Please Leave a Comment Cancel reply