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

Recall:

NaN stands for “Not-a-Number”.

Arithmetic involving non-numeric values that cannot be converted to numbers often results in NaN.

Check each:

A. 10 / 0

In JavaScript, dividing a positive number by 0 results in Infinity, not NaN.

So this logs Infinity.

B. parseInt( ' two ' )

parseInt tries to parse a numeric prefix from the string.

' two ' does not start with numeric digits, so parseInt( ' two ' ) returns NaN.

The console log prints NaN.

C. 10 / Number( ' 5 ' )

Number( ' 5 ' ) → 5.

10 / 5 → 2.

Logs 2, not NaN.

D. 10 / ' five '

' five ' is coerced to a number using Number( ' five ' ), which is NaN.

10 / NaN → NaN.

Logs NaN.

So the console logs that output NaN are from B and D.

Relevant concepts: NaN, Infinity, parseInt, Number() coercion, arithmetic with invalid numeric values.

We must track synchronous code, setTimeout callbacks (macrotasks), and Promise rejection handling (microtasks).

Step-by-step:

Synchronous code first:

Line 01–03: Schedules a timeout at 1100 ms: logs 1 (later).

Line 04: console.log(2); → logs 2.

Lines 05–09: Construct a new Promise.

The executor runs immediately.

Inside it, another setTimeout is set for 1000 ms:

setTimeout(() = > {

reject(console.log(3));

}, 1000);

Line 09–11: .catch(() = > { console.log(4); }) attached to the promise.

Line 12: console.log(5); → logs 5.

So after all synchronous code, the console has:

2

5

At 1000 ms: inner setTimeout fires

The callback:

() = > {

reject(console.log(3));

}

Inside:

console.log(3) runs first , logging 3.

console.log(3) returns undefined.

Then reject(undefined) is called.

So at about 1000 ms, we log:

3

When the promise is rejected:

The .catch handler is scheduled as a microtask .

After the current macrotask (the timeout callback) completes, the microtask queue runs.

Thus .catch(() = > { console.log(4); }) runs shortly after, in the same 1000 ms tick.

So immediately after 3, the catch handler logs:

4

Now the logs in order are:

2

5

3

4

At 1100 ms: outer setTimeout fires

The callback from line 01 runs:

console.log(1);

Logs: 1.

Final log order:

2 (line 4, sync)

5 (line 12, sync)

3 (1000 ms timeout, then inside logs before reject)

4 (promise catch microtask after rejection)

1 (1100 ms timeout)

Concatenated: 25341.

Therefore, the correct option is:

Answer: A

Study Guide / Concept References (no links):

Event loop: call stack, macrotask queue (timers), microtask queue (promises)

setTimeout scheduling and ordering

Promise rejection, .catch, and microtasks

Evaluation order of function arguments (reject(console.log(3)))

Requirement:

getNextValue() should run only if handleObjectValue(x) does not throw an error.

If an error occurs, handleError(error) should run, and getNextValue() should be skipped.

Option B:

try {

handleObjectValue(x);

getNextValue();

} catch (error) {

handleError(error);

}

Behavior:

If handleObjectValue(x) succeeds (no error):

Execution continues to getNextValue();.

If handleObjectValue(x) throws:

Control jumps directly to catch, getNextValue() is skipped.

handleError(error); is called.

This matches the requirement perfectly.

Why others are incorrect:

A: } then { is invalid JavaScript syntax.

C:

try {

handleObjectValue(x);

} catch (error) {

handleError(error);

}

getNextValue();

getNextValue() is called after the try...catch regardless of whether an error occurred. Not acceptable.

D: finally always runs:

try {

handleObjectValue(x);

} catch (error) {

handleError(error);

} finally {

getNextValue();

}

getNextValue() will execute in both success and error cases.

Therefore, the correct approach is B.

Concepts: try/catch control flow, finally semantics, placing code inside vs outside try/catch blocks.

We need to track the value of counter and the timing of each call to logCounter.

Initial state:

Line 01: counter = 0;

Line 02–04: logCounter logs the current value of counter.

Execution order and timing:

Line 05: logCounter();

Called immediately at time t = 0 ms.

counter is 0.

First log: 0.

Line 06: setTimeout(logCounter, 2100);

Schedules logCounter to run once after 2100 ms.

No log yet at this line.

Line 07–10: setInterval(() = > { counter++; logCounter(); }, 1000);

Schedules a repeating callback every 1000 ms (1 second).

First interval callback runs at t ≈ 1000 ms.

Now follow the timeline:

t = 0 ms:

logCounter(); from line 05

Logs: 0

t = 1000 ms (first interval execution):

counter++; → counter goes from 0 to 1.

logCounter(); logs 1.

t = 2000 ms (second interval execution):

counter++; → counter goes from 1 to 2.

logCounter(); logs 2.

t = 2100 ms (timeout from line 06):

logCounter(); runs again.

counter is still 2 (next setInterval will be at t = 3000 ms).

Logs 2.

So the first four logs are:

0

1

2

2

Concatenated as in the options: 0122.

Therefore, the correct choice is:

Answer: A

Study Guide / Concept References (no links):

setTimeout and setInterval timing behavior

Order of execution in the event loop

Closures capturing variables (here, logCounter using counter)

Understanding asynchronous scheduling in JavaScript