Salesforce JS-Dev-101 Dumps - Pass Salesforce Certified JavaScript Developer Exam in First Attempt 2026

The correct answer is D, because JavaScript executes synchronous code first, while the code after await runs later after the Promise resolves.

The execution order is:

console.log(2);

This runs first, so JavaScript logs:

2

Then this line runs:

asyncCall();

The asyncCall() function starts executing. Inside it, JavaScript reaches:

await delay(1000);

The delay(1000) function returns a Promise that resolves after 1000 milliseconds:

return new Promise(resolve => {

setTimeout(resolve, delay);

});

Because await pauses the rest of the asyncCall() function, this line does not run immediately:

console.log(1);

Instead, JavaScript continues executing the remaining synchronous code outside the async function:

console.log(3);

So JavaScript logs:

3

After approximately 1000 milliseconds, the Promise returned by delay(1000) resolves. Then the paused async function continues and runs:

console.log(1);

So JavaScript logs:

1

Final console output:

2

3

1

Important JavaScript concepts involved:

An async function always returns a Promise.

The await keyword pauses execution only inside the async function where it appears.

Code outside the async function continues running normally.

setTimeout() schedules its callback to run later, after the current synchronous code has finished.

Therefore, the verified answer is D. 2 3 1.

Initial values:

first = 'Who'

second = 'What'

Execution:

Inner try/catch/finally:

Line 05: throw new Error('Sad trombone');

Control goes to the inner catch.

Inner catch (lines 06--08):

catch (err) {

first = 'Why';

throw err;

}

first is set to 'Why'.

The error is rethrown.

Inner finally (lines 09--11):

finally {

second = 'When';

}

finally runs whether or not there was an error.

second becomes 'When'.

After inner finally, the rethrown error continues to propagate to the outer catch.

Outer catch (lines 12--14):

} catch (err) {

second = 'Where';

}

Because the inner try rethrew, the outer catch runs.

It sets second = 'Where'.

Final values:

first was changed to 'Why' in the inner catch and never changed again.

second became 'When' in the inner finally, and then 'Where' in the outer catch.

So:

first is 'Why'

second is 'Where'

Option B is correct.

Concepts: nested try/catch/finally, rethrowing errors, order of execution for catch vs finally, variable mutation through error propagation.

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:

Answe r: 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

console.log('Start') runs immediately (synchronous).

Promise.resolve().then(...) places the callback in the microtask queue. The .then handler does not run immediately.

console.log('End') runs next (still synchronous).

After the synchronous script finishes, the microtask queue runs, logging 'Success'.

Execution order:

Start

End

Success

This matches option B.

JavaScript Knowledge Reference (text-only)

Promise .then() callbacks execute after the current call stack finishes (microtask queue).

Synchronous logs run immediately, before promise callbacks.

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

JSON.stringify(john) converts the john object into a JSON string.

When you JSON.parse that string back, you get a plain object:

Only data that can be represented in JSON is preserved (numbers, strings, booleans, arrays, plain objects).

Functions are not preserved and are dropped.

So dan is a plain object with properties firstName and lastName, but no name method.

Therefore, dan.name is undefined, and dan.name() throws:

TypeError: dan.name is not a function

The literal string interpolation inside console.log('Hello ${...}') is also wrong (single quotes), but the code never reaches that line.