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

New behavior: sum3 now returns the sum of all elements .

Line 01: sum3([1, 2, 3]) → 1 + 2 + 3 = 6

Assertion on line 02: res === 6 → passes.

Line 04: sum3([1, 2, 3, 4]) → 1 + 2 + 3 + 4 = 10

Assertion on line 05: res === 6 → 10 === 6 is false, so the assertion fails.

So:

Line 02 assertion passes → D.

Line 05 assertion fails → C.

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.

References / 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

objA is { value: 10 }.

objB = objA; → both variables reference the same object .

changeValue(objB);:

obj.value = obj.value / 2; // modifies the shared object

So:

objA.value becomes 10 / 2 = 5.

Thus result is 5.

Person.proto is being set, but JavaScript uses Person.prototype for the prototype chain, not Person.proto.

Therefore, job is not on Person.prototype, and instances of Person do not have job via prototype.

myFather is created with new Person(), so:

myFather.firstName is ' John ' .

myFather.job is undefined.

Attempting to call myFather.job() results in:

TypeError: myFather.job is not a function

So option A is correct.

Comprehensive and Detailed Explanation:

Assuming SaleItem inherits from Item via prototype (e.g. SaleItem.prototype = Object.create(Item.prototype)):

Lines 01–02: create regItem and saleItem.

Line 03: define Item.prototype.description.

Now both regItem and saleItem (via inheritance) have a description method from Item.prototype.

Line 04: regItem.description() → ' This is a Scarf ' .

Line 05: saleItem.description() → ' This is a Shirt ' (same method, but this.name is ' Shirt ' ).

Line 07: SaleItem.prototype.description = ... overrides description only for SaleItem instances going forward.

If we imagine calling regItem.description() and saleItem.description() again after line 07:

regItem.description() still uses Item.prototype.description → ' This is a Scarf ' .

saleItem.description() now uses SaleItem.prototype.description → ' This is a discounted Shirt ' .

Those four lines correspond to option B.

Node.js event-based modules use the EventEmitter pattern.

The correct syntax for listening to events is:

emitter.on( ' eventName ' , callback)

The server library emits an ' error ' event, which must be listened to using .on.

Option analysis:

A: .catch is for Promises, not EventEmitters.

B: .error is not an EventEmitter method.

C: Correct. Listens to the ' error ' event.

D: try...catch only captures synchronous errors, not event-based asynchronous errors.

Therefore, the correct answer is option C .

JavaScript Knowledge References (text-only)

The EventEmitter API uses on(event, handler) to listen for events.

Errors emitted asynchronously cannot be caught with try...catch.

The ' error ' event is standard for Node.js modules to signal operational errors.

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.

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

The correct answer is A .

JavaScript evaluates the expression from left to right:

true + 3 + ' 100 ' + null

Step 1:

true + 3

In numeric addition, true is converted to:

1

So:

true + 3

becomes:

1 + 3

Result:

4

Step 2:

4 + ' 100 '

Because one operand is a string, JavaScript performs string concatenation instead of numeric addition.

So:

4 + ' 100 '

becomes:

" 4100 "

Step 3:

" 4100 " + null

Again, because one operand is already a string, JavaScript converts null into the string:

" null "

So the final result is:

" 4100null "

Execution summary:

true + 3 + ' 100 ' + null

// 1 + 3 + ' 100 ' + null

// 4 + ' 100 ' + null

// " 4100 " + null

// " 4100null "

Therefore, the verified answer is A .