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

To schedule a function for later execution in JavaScript, the standard built-in method is:

setTimeout(functionReference, delayInMilliseconds)

Characteristics of setTimeout():

Executes only once .

Delay is specified in milliseconds.

Requires passing the function reference , not calling the function.

Two minutes is:

2 minutes = 120 seconds = 120,000 milliseconds

Now evaluate each option:

Option A: delay(sayHello, 120000);

Incorrect.

There is no built-in delay() function in JavaScript.

Option B: setTimeout(sayHello, 120000);

Correct.

sayHello is passed as a function reference , so it will execute once after 120,000 ms.

Option C: setTimeout(sayHello(), 120000);

Incorrect.

sayHello() calls the function immediately , and the return value (undefined) is passed to setTimeout.

This executes the function right away instead of after two minutes.

Option D: setInterval(sayHello, 120000);

Incorrect.

setInterval() repeats execution every 120,000 ms.

The question requires executing the function once , so this cannot be correct.

JavaScript Knowledge References (text-only)

setTimeout() schedules a function to run once after a specified delay.

Passing functionName gives a reference; passing functionName() invokes it immediately.

setInterval() repeats indefinitely, unlike setTimeout().

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

A recursive function is a function that calls itself and has a base case to terminate the recursion.

Evaluate each option:

Option A:

const sumToTen = numVar = > {

if (numVar < 0)

return;

return sumToTen(numVar + 1);

};

This function calls itself: sumToTen(numVar + 1) — so it is recursive.

However, the base condition is if (numVar < 0) return;.

If you call sumToTen(0):

numVar < 0 is false, so it calls sumToTen(1), then sumToTen(2), and so on, incrementing forever.

There is no condition to stop the recursion when numVar increases; it will eventually cause a stack overflow.

This code does not represent a properly working recursive function with a valid termination for increasing values and is not a good example of correct recursion.

Option B:

function factorial(numVar) {

if (numVar < 0) return;

if (numVar === 0) return 1;

return numVar - 1;

}

This function does not call itself anywhere.

It has conditional returns, but there is no recursive call such as factorial(numVar - 1).

Therefore, it is not recursive at all.

Option C:

const factorial = numVar = > {

if (numVar < 0) return;

if (numVar === 0) return 1;

return numVar * factorial(numVar - 1);

};

This is a classic recursive factorial implementation.

It calls itself with a smaller argument: factorial(numVar - 1).

Base cases:

If numVar < 0, it simply returns (could be treated as invalid input).

If numVar === 0, it returns 1, which is the mathematical definition of 0! (zero factorial).

For positive integers, it correctly multiplies numVar by factorial(numVar - 1) until it reaches the base case.

This is a correct and working recursive function.

Option D (corrected):

let countingDown = function(startNumber) {

if (startNumber > 0) {

console.log(startNumber);

return countingDown(startNumber - 1);

} else {

return startNumber;

}

};

This function also calls itself: countingDown(startNumber - 1).

Base case:

When startNumber is not greater than 0 (i.e., 0 or negative), it returns startNumber and stops recursing.

For example, countingDown(3) would:

Log 3, call countingDown(2)

Log 2, call countingDown(1)

Log 1, call countingDown(0)

At 0, it hits the else branch and returns 0, ending the recursion.

This is a valid working recursive function structure (once syntax is corrected).

Therefore, the snippets that show working recursive functions are:

Answer: C, D

Study Guide / Concept References (no links):

Definition of recursion: a function calling itself

Base case vs recursive step

Recursive factorial implementation

Recursive countdown example

Importance of a terminating condition to avoid infinite recursion

setInterval(fn, delay, arg1, arg2, ...) calls fn every delay ms, passing extra arguments.

To call isDeg every 60 seconds with " cat " :

setInterval(isDeg, 60000, ' cat ' );

Why others are wrong:

A/D: isDeg( ' cat ' ) is called immediately, and its return value is scheduled, not the function.

C: setTimeout runs once after 60 seconds, not repeatedly.

Comprehensive and Detailed Explanation:

Errors thrown inside setTimeout callbacks occur asynchronously, in a different tick of the event loop. A try...catch around setTimeout itself (as in D) cannot catch errors thrown later in the scheduled callback.

To catch errors from countSheep() when it’s called asynchronously, the try...catch must wrap the call inside the timeout callback:

setTimeout(function() {

try {

countSheep();

} catch (e) {

handleError(e);

}

}, 1000);

B uses finally incorrectly and references e out of scope.

C is not valid JavaScript syntax.

D’s catch can only handle synchronous errors thrown before setTimeout returns, not those thrown inside the callback.

String: " Yay! Salesforce is amazing! "

Index positions:

' Y ' at 0, ' a ' at 1, ' y ' at 2, ' ! ' at 3, space at 4, ' S ' at 5, ' a ' at 6, ' l ' at 7, ' e ' at 8, ' s ' at 9, etc.

Substring " Sales " starts at index 5.

String.prototype.search with a regex returns the index of the first match or -1 if there is no match.

searchText.search(/sales/i);

/sales/i is case-insensitive because of the i flag.

It matches " Sales " beginning at index 5.

So result1 is 5.

searchText.search(/sales/);

/sales/ is case-sensitive.

It requires lowercase " sales " .

The text has " Sales " with uppercase S, so this does not match.

search returns -1 when there is no match.

So result2 is -1.

Console output:

First log: 5

Second log: -1

Option D matches this.

Concepts: regex search, case sensitivity vs i flag, String.prototype.search return values.

The correct answer is B because countsDeep() is executed inside the callback function passed to setTimeout(), and the try...catch block is also placed inside that same callback.

In JavaScript, setTimeout() schedules a function to run later. The outer code finishes first, and the callback runs asynchronously after the delay. Because of this, a try...catch block placed outside setTimeout() cannot catch errors thrown later inside the callback.

Correct logic:

setTimeout(function() {

try {

countsDeep();

} catch (e) {

handleError(e);

}

}, 1000);

Here, when countsDeep() runs after 1000 milliseconds, any error thrown by countsDeep() happens inside the try block. Therefore, the catch (e) block can catch that error and pass it to handleError(e).

Why the other options are incorrect:

A is incorrect because the syntax is invalid JavaScript. A valid try...catch structure must be:

try {

// code

} catch (e) {

// handle error

}

Option A incorrectly writes:

} handleError (e){

catch(e);

}

That is not valid try...catch syntax.

C is incorrect because the try...catch surrounds only the call to setTimeout(), not the later execution of countsDeep(). If countsDeep() throws an error after the timer expires, the outer catch block will not catch it.

D is incorrect for the same reason as C. In the original question, D also had a typing error: it used countSheep() instead of countsDeep(). Even after correcting that typing error, D is still incorrect because the try...catch is outside the asynchronous callback.

Promise.race() returns the result of the first settled promise , whether resolved or rejected.

The promises:

car1 → rejects in 2000 ms

car2 → resolves in 1500 ms

car3 → resolves in 3000 ms

The earliest settled promise is car2 (1500 ms), which resolves with the value:

" Car 2 completed "

Therefore, Promise.race enters the .then() branch with:

value = " Car 2 completed "

Inside the .then():

let result = ' $(value) the race. ' ;

This appears to attempt template substitution but uses incorrect syntax.

JavaScript template literals require backticks and ${expression}, for example:

`${value} the race.`

Because the code is incorrect, result is literally the string:

$(value) the race.

However, the question asks:

“What is the value of result when Promise.race executes ?”

This refers to the intended value based on which promise wins the race, not the template bug.

The winning value is:

Car 2 completed

So the correct conceptual answer is:

Car 2 completed the race.

JavaScript Knowledge References (text-only)

Promise.race() returns the first settled (resolved or rejected) promise.

The earliest resolve here is car2 (1500 ms).

Incorrect template literal syntax does not affect the identity of the winning promise.

The correct answers are B, C, D, and E .

JavaScript browser consoles support string substitution in several console output methods. String substitution means using placeholders such as:

%s

%d

%i

%f

%o

%O

%c

Example:

console.log( " User name is %s and age is %d " , " Alex " , 25);

Output:

User name is Alex and age is 25

The valid console methods from the given options are:

Option

Method

Correct?

Reason

A

message

No

console.message() is not a standard console method.

B

log

Yes

console.log() supports formatted string substitution.

C

assert

Yes

console.assert() can output a formatted message when the assertion is false.

D

info

Yes

console.info() supports formatted output like console.log().

E

error

Yes

console.error() supports formatted output and displays an error-style message.

Example with these valid methods:

console.log( " Name: %s " , " John " );

console.info( " Score: %d " , 95);

console.error( " Error code: %d " , 500);

console.assert(false, " Failed check for user: %s " , " Admin " );

So the verified answers are B, C, D, and E .