Salesforce Updated JavaScript-Developer-I Exam Questions and Answers by elyza

Understand the three promises:

car1:

let car1 = new Promise((_, reject) = >

setTimeout(reject, 2000, " Car 1 crashed in " )

);

Rejects after 2000 ms (2 seconds) with message " Car 1 crashed in " .

car2:

let car2 = new Promise(resolve = >

setTimeout(resolve, 1500, " Car 2 completed " )

);

Resolves after 1500 ms (1.5 seconds) with message " Car 2 completed " .

car3:

let car3 = new Promise(resolve = >

setTimeout(resolve, 3000, " Car 3 completed " )

);

Resolves after 3000 ms (3 seconds) with message " Car 3 completed " .

Promise.race:

Promise.race([car1, car2, car3])

then(value = > {

let result = `${value} the race.`;

})

catch(err = > {

console.log( " Race is cancelled. " , err);

});

Behavior of Promise.race:

It settles (resolves or rejects) as soon as any of the given promises settles.

It uses the value or reason from the first settled promise.

Timing:

car2 resolves in 1500 ms.

car1 rejects in 2000 ms.

car3 resolves in 3000 ms.

The first to settle is car2 at 1500 ms, with value " Car 2 completed " .

Therefore:

Promise.race resolves (not rejects) with value = " Car 2 completed " .

The .then handler runs; .catch is ignored because there is no rejection.

Inside .then:

let result = `${value} the race.`;

Substitute value:

let result = " Car 2 completed the race. " ;

So, result becomes:

Car 2 completed the race.

Compare to options:

A. Car 3 completed the race.

This would be correct if car3 were the first to resolve, which it is not (it resolves last).

B. Car 2 completed the race.

Exactly matches the first-resolving promise and the constructed message.

C. Race is cancelled.

This is the prefix of the string logged in the .catch handler, but .catch never runs because the race resolves, it does not reject first.

D. Car 1 crashed in the race.

car1 is the first rejection , but since a resolution from car2 happens earlier, the race is already settled successfully before car1 rejects.

Thus the correct value of result as set in the .then block is:

Answer: B

Study Guide / Concept References (no links):

Promise.race(iterable) semantics (first settled promise wins)

setTimeout and timing interactions with Promises

Resolve vs reject paths and .then / .catch

Template literals and string interpolation for building result messages

The correct answer is A , not D.

Inside myFunction(), the declaration:

var b = 1;

is hoisted to the top of the function scope, but only the declaration is hoisted, not the assignment. So internally, JavaScript treats the function approximately like this:

function myFunction() {

var b;

a = a + b;

b = 1;

}

Now examine this line:

a = a + b;

Before JavaScript can assign a value to a, it must first evaluate the right-hand side:

a + b

At this point:

b

exists locally because var b was hoisted, so its value is:

undefined

However:

a

has not been declared anywhere. Reading an undeclared variable causes a:

ReferenceError

So this line throws an error before assignment happens:

a = a + b;

Because the error occurs on that line, the next line inside the function is never executed:

var b = 1;

Also, because the error is not handled with try...catch, the program stops before reaching:

console.log(a);

console.log(b);

Therefore, the accurate statement is:

Line 02 throws a reference error, therefore line 03 is never executed.

So the verified answer is A .

When async is added to a function:

async function example() {}

JavaScript guarantees:

The function always returns a Promise , regardless of what is returned inside.

Inside the function, await pauses execution until a Promise resolves.

Code appears synchronous even though it uses asynchronous behavior.

Analysis of each option:

A incorrect: Not " sometimes " —an async function always returns a Promise.

B incorrect: Async functions can be called just like normal functions.

C incorrect: Async/await has nothing to do with classes specifically.

D correct: This is the standard description: “Async functions behave asynchronously but allow writing code that looks synchronous.”

JavaScript Knowledge References (text-only)

async functions always return Promises.

await pauses execution of the async function.

Async/await syntax creates synchronous-looking code on top of asynchronous operations.

The correct answers are A and B .

The original question contains a typing error where 66 should be corrected to the logical AND operator:

& &

A is correct because it first evaluates the logical AND expression and then converts the final result to a Boolean:

Boolean(exp1 & & exp2)

The & & operator returns the first falsy value or the last truthy value. Wrapping the result in Boolean() ensures the final result is strictly either:

true

or:

false

Example:

Boolean( " hello " & & 123);

This returns:

true

B is also correct because it converts both expressions to Boolean values first, then applies logical AND:

Boolean(exp1) & & Boolean(exp2)

This guarantees that both sides of the & & operation are Boolean values.

Example:

Boolean( " hello " ) & & Boolean(123);

This returns:

true

C is incorrect because it uses the bitwise AND operator:

&

This is not the same as logical AND:

& &

Bitwise AND converts values into numbers and compares their binary representation. It does not reliably return a Boolean logical result.

D is incorrect as written because the question gives the expressions as exp1 and exp2, but option D uses var1 and var2. After correction, it would be the same idea as option B.

Therefore, the verified answers are A and B .