Get Salesforce JS-Dev-101 Exam Practice Questions - Real and Updated

Answer : B, D

Facts about JavaScript Promises:

runParallel() is declared async, which means it always returns a Promise.

Promises are consumed using .then(), .catch(), and .finally().

There is no .done() method in native JavaScript Promises.

The async keyword cannot be placed before a function call (option A is invalid syntax).

Analysis of each option:

A . async runParallel().then(data);

Invalid syntax. async cannot prefix an expression.

B . Valid. Calls the function and attaches a .then() handler.

C . Invalid. .done() is not part of JavaScript Promise API.

D . Valid. Calls runParallel() and chains .then().

Therefore the correct answers are B and D.

JavaScript Knowledge Reference (text-only)

async functions return Promises.

Promises use .then() to retrieve resolved values.

.done() is not part of the standard Promise interface.

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

Answer : A, D

We want:

const addByEight = addBy(8);

const sum = addByEight(50);

And we need sum to be 58.

That means:

addBy(8) must return a function.

That returned function, when called with 50, must compute 8 + 50.

So addBy must be a higher-order function that returns another function capturing num1 and later using it with num2 (a closure).

Option A

const addBy = function(num1) {

return function(num2) {

return num1 + num2;

}

}

Step-by-step:

Call addBy(8):

num1 is 8.

The function returns an inner function: function(num2) { return num1 + num2; }.

So addByEight becomes this inner function, with num1 closed over as 8.

Then call addByEight(50):

num2 is 50.

The body computes num1 + num2, i.e., 8 + 50 = 58.

Therefore, with Option A in place:

const addByEight = addBy(8); // returns inner function

const sum = addByEight(50); // 58

So sum is 58. Option A is correct.

Option D (corrected)

const addBy = (num1) => {

return function(num2) {

return num1 + num2;

}

}

This is essentially the same logic expressed with an arrow function for the outer function:

Call addBy(8):

num1 is 8.

Returns the inner function function(num2) { return num1 + num2; }.

Call addByEight(50):

num2 is 50.

Computes num1 + num2 8 + 50 = 58.

So again:

const addByEight = addBy(8); // inner function with num1 = 8

const sum = addByEight(50); // 58

Option D is also correct.

Thus, A and D are the two functions that satisfy the requirement.

Why B and C are incorrect

Option B:

const addBy = function(num1) {

return num1 * num2;

}

This does not return a function; it returns a value.

addBy(8) returns 8 * num2, but num2 is not defined in this scope, which would cause a ReferenceError.

Also, addByEight would be a number (if num2 existed), not a function, so addByEight(50) would fail.

Option C:

const addBy = (num1) => num1 + num2;

Again, addBy returns a value, not a function.

addBy(8) returns 8 + num2, but num2 is not defined, so this is also invalid due to ReferenceError.

addByEight would be a number (or error), not a function.

Neither B nor C creates the required closure nor returns a function to be called later.

Reference / Study Guide concepts (no links):

Higher-order functions in JavaScript

Closures: inner functions capturing outer variables (num1)

Arrow functions vs function expressions

Returning functions from functions (function factories / currying)

Scope and ReferenceError when a variable is not defined

Answer : B

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().

Answer : A

Object.preventExtensions(obj)

This built-in JavaScript method marks an object so that no new properties can be added to it.

Existing properties can still be read and updated, but adding new ones is disallowed.

const newObjBook = objBook;

Both variables reference the same object in memory. JavaScript objects are assigned by reference, not copied.

newObjBook.author = 'Robert';

Because the object has been marked as non-extensible, JavaScript will not allow new properties to be added.

The behavior depends on mode:

In non-strict mode: the assignment silently fails and does nothing.

In strict mode: this would throw a TypeError.

Since nothing indicates strict mode, this is non-strict behavior, making the assignment fail silently.

Therefore, the object remains:

{ title: 'JavaScript' }

Both objBook and newObjBook point to the same unchanged object.

This matches option A.

JavaScript knowledge references (text-only)

Object.preventExtensions() prevents adding new properties.

Assigning an object to another variable copies the reference, not the object.

Adding a property to a non-extensible object silently fails in non-strict mode.

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

Answer : B, D, E

:

Behavior of non-strict global code

The script does not begin with a 'use strict' directive at the top level, so the global code (outside any function) runs in non-strict (sloppy) mode.

Line 01: x = 3.14;

In non-strict mode, assigning to an undeclared identifier (no var, let, or const) creates an implicit global variable. So after line 01, x exists and equals 3.14.

Line 08: z = x;

This also runs in non-strict mode. Since x is already defined (from line 01), z is set to 3.14. Therefore, statement B is correct: z is equal to 3.14.

Scope of 'use strict' inside a function

The line:

'use strict';

inside myFunction is a directive prologue for that function, not for the entire file. This means:

Strict mode applies only within the body of myFunction, from the directive to the end of that function.

It does not retroactively affect code before the function or code outside of it.

Therefore:

Statement A is incorrect: 'use strict' is not ''hoisted'' to affect the whole file. It only affects the function body.

Statement C is incorrect: strict mode does not apply from line 04 to the end of the file; it only applies within myFunction, not to global lines like 01, 08, or 09.

Execution of myFunction in strict mode

When myFunction is called on line 09:

function myFunction() {

'use strict';

y = x;

}

Within this function:

Strict mode is active for its body.

In strict mode, assigning to an undeclared variable (like y here) is not allowed and results in a ReferenceError at runtime.

So line 05:

y = x;

throws a ReferenceError because y is not declared with var, let, or const.

Therefore, statement E is correct: line 05 throws an error.

Why statement D is considered correct

Statement D says:

'use strict' has an effect only on line 05.

In terms of execution in this specific code:

The only executable statement in myFunction that is affected by strict mode is the assignment on line 05.

The directive itself on line 04 is not a ''normal'' runtime operation; it is a directive that sets the mode.

There are no other statements inside the function that behave differently under strict mode; only the line that assigns to the undeclared variable shows a strict-mode effect.

So, describing the practical execution behavior of this snippet, strict mode manifests its effect only on line 05, making statement D correct in this context.

Summary of each option:

A: Incorrect -- strict does not apply to all lines in the file.

B: Correct -- z becomes 3.14 in non-strict global code.

C: Incorrect -- strict does not affect code outside the function.

D: Correct -- in this code, the only behavioral effect of strict mode is on line 05.

E: Correct -- line 05 throws a ReferenceError due to assignment to undeclared y under strict mode.

JavaScript knowledge references (descriptive, no links):

In non-strict (sloppy) mode, assigning to an undeclared identifier creates a global variable.

'use strict' inside a function body enables strict mode for that function only.

In strict mode, assigning to an undeclared variable results in a ReferenceError.

Directive prologues ('use strict') affect only their containing function or script, not other scopes.

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