JavaScript-Developer-I Exam Dumps - Salesforce Certified JavaScript Developer (JS-Dev-101)

JavaScript defines two main page-loading events:

DOMContentLoaded Fires when the HTML document has been completely parsed. External resources like images, stylesheets, iframe contents, etc. may not be loaded yet .

load event on window Fires when:

HTML is fully parsed

All dependent resources (images, scripts, CSS, fonts, etc.) are fully loaded

The requirement states:

“when the webpage is fully loaded (HTML content and all related files )”

This aligns exactly with the window load event .

Implementation:

window.addEventListener( " load " , personalizeWebsiteContent);

This matches option B.

JavaScript knowledge references (text-only)

DOMContentLoaded fires after HTML parsing only.

load fires after all page resources finish loading.

The window object is the correct target for listening to the full load event.

The correct answers are C and D .

Arrays in JavaScript are objects. When an array variable is assigned directly to another variable, both variables point to the same array in memory.

Option C is correct:

let arr2 = arr;

This does not create a new array. It creates another reference to the same array.

Example:

arr2.push(6);

console.log(arr);

Output:

[1, 2, 3, 4, 5, 6]

Changing arr2 also affects arr because both variables reference the same array.

Option D is also correct:

let arr2 = arr.sort();

The sort() method sorts the array in place and returns the same array reference. Therefore, arr2 refers to the same array object as arr.

The incorrect options create copies:

let arr2 = arr.slice(0, 5);

creates a shallow copy.

let arr2 = Array.from(arr);

also creates a new shallow copy.

So the two lines that make arr2 reference the original arr are C and D .

The question is about:

Web frameworks that run on Node.js

Used to build servers and APIs

With established communities.

From the given options:

Angular:

A front-end framework running in the browser, not a Node.js server framework.

Gatsby:

A React-based static site generator; uses Node tooling but is not primarily a Node server framework.

Next / Next.js:

Server-side rendering / full-stack frameworks built on Node.js and React.

Used to create both server-rendered pages and APIs.

They have active communities and are “seasoned” compared to a hypothetical Minimalist.js.

Although typical Node back-end frameworks would include Express.js, Koa, or NestJS, given the options provided, the best fits for server-side frameworks with Node.js and an ecosystem are:

Next (interpreted as Next.js)

Next.js

Thus, the correct pair from the list is B and D.

Concepts: Node.js web frameworks, server-side rendering, community-backed frameworks vs minimal/new frameworks.

Person instances have:

firstName and lastName as string properties.

A name method that returns a combined string: `${this.firstName},${this.lastName}`.

Object.assign({}, john) creates a shallow copy of john into a new object, dan.

After:

dan.firstName = ' Dan ' ;

dan.name() returns " Dan,Doe " .

Analysis of options:

A: dan.firstName() and dan.lastName() are function calls , but firstName/lastName are strings, not functions → TypeError.

B: Calls the defined method and uses both names correctly.

C: dan.name is a function reference; you’d still need to call it: dan.name().

D: dan.firstName + dan.lastName is " DanDoe " , no separator. It accesses the properties but not in the method the developer defined.

The intended way, using the provided API, is dan.name().

console.log( ' Start ' ) runs immediately (synchronous).

Promise.resolve().then(...) places the callback in the microtask queue. The .then handler does not run immediately.

console.log( ' End ' ) runs next (still synchronous).

After the synchronous script finishes, the microtask queue runs, logging " Success " .

Execution order:

Start

End

Success

This matches option B .

JavaScript Knowledge References (text-only)

Promise .then() callbacks execute after the current call stack finishes (microtask queue).

Synchronous logs run immediately, before promise callbacks.

==================================================

The correct answer is D , because JavaScript executes synchronous code first, while the code after await runs later after the Promise resolves.

The execution order is:

console.log(2);

This runs first, so JavaScript logs:

2

Then this line runs:

asyncCall();

The asyncCall() function starts executing. Inside it, JavaScript reaches:

await delay(1000);

The delay(1000) function returns a Promise that resolves after 1000 milliseconds:

return new Promise(resolve = > {

setTimeout(resolve, delay);

});

Because await pauses the rest of the asyncCall() function, this line does not run immediately:

console.log(1);

Instead, JavaScript continues executing the remaining synchronous code outside the async function:

console.log(3);

So JavaScript logs:

3

After approximately 1000 milliseconds, the Promise returned by delay(1000) resolves. Then the paused async function continues and runs:

console.log(1);

So JavaScript logs:

1

Final console output:

2

3

1

Important JavaScript concepts involved:

An async function always returns a Promise.

The await keyword pauses execution only inside the async function where it appears.

Code outside the async function continues running normally.

setTimeout() schedules its callback to run later, after the current synchronous code has finished.

Therefore, the verified answer is D. 2 3 1 .

We have a ternary:

account.style.display = accountName.includes(parsedSearchString)

? /* if true */

/* if false */;

Requirement:

If the account matches the search string → show it.

If it does not match → hide it.

For display:

Show: ' block ' (or similar visible value).

Hide: ' none ' .

So we want:

account.style.display = accountName.includes(parsedSearchString)

? ' block '

' none ' ;

That corresponds to option A.

Why others are wrong:

B, C use values suitable for visibility, not display.

D ( ' none ' : ' block ' ) inverts the logic, hiding matches and showing non-matches.

A correct conversion from constructor-function syntax to ES6 class syntax must satisfy:

Use a constructor(name, price) method.

Assign instance properties inside the constructor.

Define methods without function keyword directly in the class body.

Use proper JavaScript template literals (backticks).

Evaluate each option:

Option A

Incorrect template literal syntax: uses single quotes with ${} which will not interpolate.

Option B

Incorrect:

The method vehicle() is not recognized as a constructor.

The constructor method is missing.

Option C

Incorrect:

The constructor has no parameters, but uses name and price which are undefined.

Option D

Correct:

Uses proper constructor with parameters.

Correct assignment of instance properties.

Correct template literal using backticks.

This is the valid ES6 class translation.

JavaScript Knowledge References (text-only)

ES6 classes require a constructor method for initialization.

Template literals must use backticks.

Methods inside classes are defined without the function keyword.

Omitted constructor parameters lead to undefined instance fields.