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

Definitions:

False negative → The test reports a failure even though the feature actually works.

False positive → The test reports success when it should not.

True positive → Correctly identifies something is working.

True negative → Correctly identifies something is not working.

In this scenario:

The checkout button does exist , so the feature works.

The test fails incorrectly , because it is checking for the wrong selector.

That is the definition of a false negative .

JavaScript Knowledge References (text-only)

Test outcome classification: false negative = feature works but test fails.

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

This code uses:

A for...of loop to iterate over values in array.

break to exit the loop entirely when output > 10.

continue to skip even numbers.

It sums only certain numbers into output.

Let’s walk through the loop step by step.

Initial values:

array = [1,2,3,4,5,6,7,8,9,10,11]

output = 0

Loop: for (let num of array) { ... }

First iteration: num = 1

Line 05: if (output > 10) → 0 > 10 is false → no break.

Line 08: if (num % 2 == 0) → 1 % 2 == 1, not 0, so false → no continue.

Line 11: output += num → output = 0 + 1 = 1.

Second iteration: num = 2

output > 10 → 1 > 10 is false → no break.

num % 2 == 0 → 2 % 2 == 0, so true → continue.

Because of continue, line 11 is skipped.

output remains 1.

Third iteration: num = 3

output > 10 → 1 > 10 is false.

num % 2 == 0 → 3 % 2 == 1, false → no continue.

output += num → output = 1 + 3 = 4.

Fourth iteration: num = 4

output > 10 → 4 > 10 is false.

num % 2 == 0 → 4 % 2 == 0, true → continue.

Skip sum; output remains 4.

Fifth iteration: num = 5

output > 10 → 4 > 10 is false.

num % 2 == 0 → 5 % 2 == 1, false.

output += num → output = 4 + 5 = 9.

Sixth iteration: num = 6

output > 10 → 9 > 10 is false.

num % 2 == 0 → 6 % 2 == 0, true → continue.

output remains 9.

Seventh iteration: num = 7

output > 10 → 9 > 10 is false.

num % 2 == 0 → 7 % 2 == 1, false.

output += num → output = 9 + 7 = 16.

Eighth iteration would be num = 8, but:

At the top of the loop body, line 05 is checked again:

if (output > 10) → 16 > 10 is true, so break; is executed.

When break runs:

The loop terminates immediately.

No further iterations (for num = 8, 9, 10, 11) are executed.

Therefore, output stays at 16.

Final value of output after the loop ends is 16.

This matches option A.

Why other options do not match:

B. 25: Would require adding more odd numbers (e.g., 9, 11) after 7, but the loop stops early due to output > 10.

C. 11: Would be smaller; the actual sum of 1 + 3 + 5 + 7 until break is 16.

D. 36: Would require summing many more values (e.g., most or all odd numbers up to 11), but again, the break condition stops the loop once output exceeds 10.

So:

Answer: A

JavaScript knowledge / Study Guide references (concept names only, no links):

for...of loop over arrays

break statement in loops (terminating a loop early)

continue statement in loops (skipping to the next iteration)

Modulo operator % to test even and odd numbers

Step-by-step execution and control flow in loops

Currently:

sayHello expects a value name and prints it.

world is a function that returns ' World ' .

sayHello(world); passes the function object itself, not the result of calling it.

So name inside sayHello is a function, not the string " World " .

To keep the call sayHello(world) yet get " World " , sayHello must call the function parameter:

const sayHello = (name) = > {

console.log( ' Hello ' , name());

};

Now:

sayHello(world) passes the function.

Inside sayHello, name() calls world(), which returns " World " .

The console logs " Hello World " .

Why the others are wrong:

B: Changing line 7 to }(); would attempt to IIFE the function definition and break the declaration.

C: sayHello(world)() would try to call the return value of sayHello, which is undefined, causing an error.

D: Changing world to a function declaration does not change the fact that it is passed as a function reference; sayHello still prints the function object, not ' World ' .

The correct answer is B .

This question is about the event-driven programming model commonly used in Node.js. Many Node.js libraries expose an .on() method to register callback functions for specific events.

The correct pattern is:

ws.on( ' eventName ' , callbackFunction);

In this case, the developer needs to listen for two events:

' connect '

and:

' error '

The correct implementation is:

ws.on( ' connect ' , () = > {

console.log( ' Connected to client ' );

});

ws.on( ' error ' , (error) = > {

console.log( ' ERROR ' , error);

});

This registers one listener for successful connection and another listener for connection errors.

Why this works professionally:

ws.on( ' connect ' , callback) tells the library:

“When the connection event happens, execute this callback.”

ws.on( ' error ' , callback) tells the library:

“When an error event happens, execute this callback and pass the error object into it.”

Option A is incorrect because .catch() is used with Promises. The question specifically says the client library is built using events and callbacks , not Promise chaining.

Option D is incorrect because try...catch only catches synchronous errors during the immediate execution of ws.connect(). It will not reliably catch asynchronous connection errors emitted later by the web socket client.

Option C is identical to option B in the provided question. Since the expected answer normally requires selecting one option, B is selected as the verified answer.

Therefore, the verified answer is B .

First, compute sampleText:

let codeName = ' Bond ' ;

let sampleText = `The name is ${codeName}, Jim ${codeName}`;

The template literal evaluates to:

" The name is Bond, Jim Bond "

Now evaluate each statement:

Option A: sampleText.includes( ' Jim ' );

String.prototype.includes(substring) returns true if substring occurs anywhere in the string.

sampleText clearly contains " Jim " ( " The name is Bond, Jim Bond " ).

So this returns true.

Option B: sampleText.includes( ' The ' , 1);

includes(searchString, position) starts searching from the given position index.

" The name is Bond, Jim Bond " has " The " starting at index 0.

Starting search at index 1 means " The " at index 0 is not considered, and there is no second " The " .

So this returns false.

Option C: sampleText.includes( ' Jim ' , 4);

" Jim " appears after " The name is Bond, " which is longer than 4 characters; the index of " Jim " is well past 4.

So when searching from index 4, " Jim " is still found.

This returns true.

Option D: sampleText.indexOf( ' Bond ' ) !== -1;

String.prototype.indexOf(substring) returns:

-1 if the substring is not found,

Otherwise, the starting index of the first occurrence.

" Bond " appears twice in " The name is Bond, Jim Bond " .

So sampleText.indexOf( ' Bond ' ) is some non-negative index (for the first occurrence).

Therefore indexOf( ' Bond ' ) !== -1 is true.

Option E: sampleText.substring( ' Jim ' );

substring expects numeric indexes: substring(startIndex, endIndex?).

If given a string " Jim " as the argument, JavaScript coerces it to a number:

Number( ' Jim ' ) → NaN

NaN for startIndex is treated as 0.

So sampleText.substring( ' Jim ' ) is effectively sampleText.substring(0), which returns the full string " The name is Bond, Jim Bond " .

This is a string , not a boolean. The question asks “which code statements return true?”

This statement returns a string, not the boolean value true.

Thus, the three statements that actually return true (boolean) are:

Answer: A, C, D

Study Guide / Concept References (no links):

Template literals and ${} interpolation

String.prototype.includes(searchString, position?)

String.prototype.indexOf(substring) and checking for !== -1

String.prototype.substring(start, end?) and argument coercion

Boolean vs non-boolean return types in string methods

The correct answer is C .

The typing errors in the options should be corrected as follows:

event.stopPropagation();

The stopPropagation() method is used to stop an event from continuing through the DOM event propagation path.

A click event normally goes through these phases:

Capturing phase → Target phase → Bubbling phase

Because the event listener is attached to the button:

el.addEventListener( " click " , printMessage, false);

the function printMessage receives the click event when the button is clicked. To stop the event from bubbling up to parent elements, the event object should be accepted as a parameter and stopPropagation() should be called inside the event handler.

Corrected code:

< html >

< body >

< div id= " logo " > Hello Logo! < /div >

< button id= " test " > Click me < /button >

< /body >

< script >

function printMessage(event) {

event.stopPropagation();

console.log( ' This is a test message ' );

}

let el = document.getElementById( ' test ' );

el.addEventListener( " click " , printMessage, false);

< /script >

< /html >

Why this is correct:

event.stopPropagation();

prevents the click event from moving upward to ancestor elements after the button’s handler runs.

Why the other options are incorrect:

A and B are incorrect because removeEventListener() is used to remove a previously registered event listener. It does not stop event bubbling for the current event.

D is incorrect because stopPropagation() should be called inside the active event handler that receives the event object. In this case, that function is:

printMessage(event)

Therefore, the verified answer is C .

JavaScript has one numeric data type for all real numbers, whether integers or decimals.

This type is simply called:

Number

It follows the IEEE 754 double-precision floating-point standard internally,

but JavaScript does not expose separate types like float, double, or decimal.

Therefore:

It is not Float → JavaScript does not have float primitives.

It is not Double → this refers to the underlying IEEE 754 representation, but JavaScript ' s type is still just “Number.”

It is not Decimal → JavaScript has no built-in decimal type.

The correct answer is Number .

JavaScript Knowledge References (text-only)

JavaScript has a single numeric type: Number.

All numbers—integers, fractions, floating point—use the Number type.

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

Behavior of Promise.prototype.finally:

.finally(handler) registers a callback that runs when the promise is settled , meaning:

Either fulfilled (resolved) , or

rejected .

Important points:

The finally callback does not receive the promise’s value or error (unlike then and catch).

It is executed after the promise is settled, but before the resolution value or rejection reason is passed further down the chain.

It runs in both success and failure paths.

In the given code:

The promise may either:

Call reject( ' fraction > 0.5, ' + fraction) if fraction > 0.5, or

Call resolve(fraction) otherwise.

In both cases:

If it resolves , .then(() = > console.log( ' resolved ' )) runs, and then .finally(...) is executed.

If it rejects , .catch((error) = > console.error(error)) runs, and then .finally(...) is executed.

So .finally runs:

Not just “when rejected”.

Not just “when resolved”.

But whenever the promise is resolved or rejected .

Therefore, the correct choice is:

D. When resolved or rejected .