Free Salesforce JavaScript-Developer-I Practice Exam with Questions & Answers

The correct answer is C .

When getAvailability(item) returns true, the code inside the if block executes:

var msg = " Username available " ;

return msg;

The variable msg receives the string value:

" Username available "

Then that same value is returned from the function.

The key point is that var is function-scoped, not block-scoped. So msg belongs to the function scope of getAvailabilityMessage(). However, because the return msg; statement is inside the same if block, the function immediately returns the assigned string when the username is available.

Option A is incorrect because msg is defined before it is returned.

Option B is incorrect because " newUserName " is not assigned or returned anywhere in the function.

Option D would only happen if getAvailability(item) returned false, because then the function would finish without an explicit return value.

For the available username scenario, the verified answer is C .

The function:

async function functionUnderTest(isOK) {

if (isOK) return ' OK ' ;

throw new Error( ' not OK ' );

}

Behavior:

If isOK is true:

The function resolves (fulfills the promise) with value ' OK ' .

If isOK is false:

The function throws, which in an async function becomes a rejected promise with Error( ' not OK ' ).

We want an assertion that accurately tests the successful path for isOK === true.

Key points about console.assert:

Signature: console.assert(condition, message?)

If condition is falsy , it logs message as an assertion failure.

If condition is truthy , nothing is logged.

We also must understand await:

await functionUnderTest(true) will resolve to the string ' OK ' .

Now evaluate options.

Option A:

console.assert(await functionUnderTest(true), ' OK ' );

await functionUnderTest(true) → ' OK ' (truthy).

console.assert( ' OK ' , ' OK ' );

Condition is ' OK ' (truthy), so assertion passes.

The message ' OK ' is only shown if the condition is falsy, which it is not.

This correctly verifies that the promise resolved (i.e., did not reject). Among the given options, this is the only one that both:

Uses await properly on the async function, and

Associates the message with the expected success " OK " .

Option B:

console.assert(await (functionUnderTest(true), ' not OK ' ));

Inside the parentheses, the comma operator (a, b) evaluates a, discards it, and returns b.

So (functionUnderTest(true), ' not OK ' ):

Calls functionUnderTest(true) (returns a promise, but its result is discarded),

The expression evaluates to the string ' not OK ' .

Then await ' not OK ' just resolves to ' not OK ' immediately (not a promise).

console.assert( ' not OK ' );

Condition is ' not OK ' (truthy), so the assertion passes regardless of what functionUnderTest actually does.

This does not meaningfully test the function and is misleading.

Option C:

console.assert(functionUnderTest(true), ' OK ' );

functionUnderTest(true) returns a Promise , not the string ' OK ' directly.

A Promise object is always truthy.

So console.assert(promise, ' OK ' ) will pass, even if the promise later rejects.

Also, there is no await, so we are not actually waiting for the async result.

This is not a correct way to assert on an async function’s resolved value.

Option D:

console.assert(await functionUnderTest(true), ' not OK ' );

await functionUnderTest(true) still resolves to ' OK ' (truthy).

console.assert( ' OK ' , ' not OK ' ); passes.

However, the message ' not OK ' is the opposite of what we expect for the success case and is only used when the condition fails.

This makes the assertion logically inconsistent with the function behavior (it would show " not OK " if the assertion failed).

Therefore, the only assertion that:

Properly waits on the async function, and

Has expectation text that matches the successful behavior ( ' OK ' )

is:

Answer: A

Study Guide / Concept References (no links):

async and await behavior in JavaScript

Promises resolving vs rejecting in async functions

console.assert(condition, message) usage

Truthy and falsy values in JavaScript

Comma operator (a, b) semantics

At line 03, the developer assigns:

Item.prototype.description = function() { return ' This is a ' + this.name; }

This affects all objects whose prototype chain includes Item.prototype .

regItem inherits from Item → gets this method.

saleItem, as an instance of SaleItem, also inherits Item.prototype (since SaleItem uses prototype inheritance from Item), so it also has this method at this moment.

Outputs at lines 04 and 05:

regItem.description() → " This is a Scarf "

saleItem.description() → " This is a Shirt "

At line 07, the developer overrides the method on SaleItem.prototype :

SaleItem.prototype.description = function() {

return ' This is a discounted ' + this.name;

}

From this point:

regItem still uses the Item.prototype version

saleItem uses the overridden SaleItem.prototype version

Outputs at lines 08 and 09:

regItem.description() → " This is a Scarf "

saleItem.description() → " This is a discounted Shirt "

Combining all results:

This is a Scarf

This is a Shirt

This is a Scarf

This is a discounted Shirt

This matches option B .

JavaScript Knowledge References (text-only)

Objects created from constructor functions use prototype chaining.

Overriding a subclass prototype method does not affect the parent class prototype.

Instances inherit the most specific version of the method on their prototype chain.

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

Comprehensive and Detailed Explanation:

The loop removes every 4:

Start: [1, 2, 3, 4, 4, 5, 4, 4]

i=0 → 1 (no change)

i=1 → 2 (no change)

i=2 → 3 (no change)

i=3 → 4 → splice removes index 3 → [1,2,3,4,5,4,4], then i-- → 2

Next loop, i=3 → 4 again → splice → [1,2,3,5,4,4], i-- → 2

i=3 → 5 (no change)

i=4 → 4 → splice → [1,2,3,5,4] , i-- → 3

i=4 → 4 → splice → [1,2,3,5], i-- → 3

Next i=4, array.length is 4 → loop ends.

All 4s removed, final array: [1, 2, 3, 5].

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.

Person instances have:

firstName and lastName as string properties.

A name method that returns a combined string: `${this.firstName},${this.lastName}`.

Object.assign({}, john) creates a shallow copy of john into a new object, dan.

After:

dan.firstName = ' Dan ' ;

dan.name() returns " Dan,Doe " .

Analysis of options:

A: dan.firstName() and dan.lastName() are function calls , but firstName/lastName are strings, not functions → TypeError.

B: Calls the defined method and uses both names correctly.

C: dan.name is a function reference; you’d still need to call it: dan.name().

D: dan.firstName + dan.lastName is " DanDoe " , no separator. It accesses the properties but not in the method the developer defined.

The intended way, using the provided API, is dan.name().

Evaluate each test:

A. sum3([1, ' 2 ' ])

Array length is 2 → line 4: arr[0] + arr[1] → 1 + ' 2 ' → ' 12 ' (string).

Assertion: ' 12 ' == 12 is true (type coercion). However, this “test” is not logically correct: a numeric sum function should not be expected to return ' 12 ' as a string. It passes only because of weak equality coercion, so it is not a good/valid test of correct behavior.

B. sum3([ ' hello ' , 2, 3, 4])

Length ≥ 3 → line 5: ' hello ' + 2 + 3 → ' hello2 ' + 3 → ' hello23 ' .

' hello23 ' === NaN is always false because NaN is never equal to anything, not even itself. This assertion fails and also misunderstands how NaN comparisons work.

C. sum3([-3, 2])

Length 2 → -3 + 2 = -1.

Assertion: -1 === -1 → true. This is a correct and meaningful test.

D. sum3([0])

Length 1 → returns arr[0] → 0.

Assertion: 0 === 0 → true. Also a correct and meaningful test.

Therefore, the valid and logically correct tests here are C and D.

Evaluate each option:

A. Arguments for .then() are optional.

This is correct.

then() has the signature:

promise.then(onFulfilled?, onRejected?)

Both arguments (onFulfilled and onRejected) are optional.

If a callback is not supplied, JavaScript provides a default pass-through handler.

B. .then() cannot be added after a catch.

Incorrect.

Promises support chaining in any order:

promise

catch(...)

then(...);

After a catch, the chain continues normally.

C. .then() manipulates and returns the original promise.

Incorrect.

then() always returns a new promise , not the original one.

This is fundamental to promise chaining behavior.

D. Returning values in .then() is not necessary.

Incorrect.

If you want the next .then() in the chain to receive a value, the current .then() must explicitly return it:

then(value = > {

return value * 2; // passes to next .then()

})

If nothing is returned, the next .then() receives undefined.

Why A is correct

It is the only statement that accurately describes built-in Promise behavior:

then() accepts optional arguments.

JavaScript Knowledge References (text-only)

.then(onFulfilled?, onRejected?) accepts optional handlers.

Promise chaining creates new promises for each .then().

catch() can be followed by additional .then() calls.

Returning inside .then() passes values to the next step in the chain.

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

The correct answer is C .

The original option contains a typing error. It should use the existing variable name:

let numberValue = Number(strNumber);

The value of strNumber is a string:

' 12345 '

Using Number() converts the numeric string into a JavaScript number:

12345

So after execution:

typeof numberValue;

returns:

" number "

Professional review of each option:

Option

Result

Explanation

A

Incorrect

JavaScript does not have a standard global Integer() conversion function.

B

Incorrect

Strings do not have a standard .toInteger() method.

C

Correct

Number(strNumber) correctly converts ' 12345 ' into 12345.

D

Incorrect

This is not valid JavaScript casting syntax.

A commonly used alternative would also be:

let numberValue = parseInt(strNumber, 10);

But from the provided answer choices, the verified answer is C .