Salesforce JS-Dev-101 Exam Questions

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.

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.

The answer is B because JavaScript uses lexical scope.

When a function is created inside another function, the inner function can access variables from the outer function where it was defined.

For example:

function first() {

let a = 10;

function second() {

console.log(a);

}

second();

}

Here, a belongs to the outer function first(). The inner function second() can access it because JavaScript looks for variables through the scope chain.

The lookup works like this:

1. Look inside second()

2. If not found, look inside first()

3. If not found, look in the global scope

Since a is found in the outer function's scope, second() can use it.

This is also the basis of a closure. A closure allows an inner function to remember and access variables from its outer lexical environment.

Why the other options are incorrect:

A is not the best answer because a is not declared inside second() itself.

C is incorrect because the prototype chain is used for object property lookup, not local variable scope lookup.

D is incorrect because hoisting explains how declarations are moved during compilation, but it does not explain why an inner function can access an outer function's variable.

Therefore, the verified answer is B.

Current behavior:

Clicking <td> triggers the click event on row1, then bubbles up to <table>.

printMessage runs, logs 'Row log', then event.stopPropagation() stops the event from bubbling to the table.

So 'Table log' never appears.

To allow the table's inline onclick to run after the row handler:

Remove the propagation stop:

function printMessage(event) {

console.log('Row log');

// event.stopPropagation(); // remove this

}

Now the event bubbles:

printMessage logs 'Row log'.

The table's onclick runs, logging 'Table log'.

Option A only changes capture/bubble phase but still stops propagation. C does nothing meaningful (stopPropagation takes no arguments). B removes the row handler entirely.

execute() returns a Promise that immediately calls reject().

So promise starts in a rejected state.

When a Promise is rejected and you chain .then() calls without rejection handlers, all those .then() callbacks are skipped until a .catch() is encountered:

promise

.then(...) // skipped

.then(...) // skipped

.then(...) // skipped

.catch(...) // executed

.then(...); // executed after catch

Execution:

.then(() => console.log('Resolved1')) is skipped.

.then(() => console.log('Resolved2')) is skipped.

.then(() => console.log('Resolved3')) is skipped.

.catch(() => console.log('Rejected')) runs and logs Rejected.

The .catch() returns a resolved Promise (no explicit return, so undefined), so the next .then() runs:

.then(() => console.log('Resolved4')) logs Resolved4.

Final output:

Rejected

Resolved4

This matches option D.