Free Practice Questions for Salesforce JavaScript-Developer-I Exam

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 .

Event-driven Node-style APIs expose events via .on(eventName, handler).

To listen for error events:

server.on( ' error ' , (error) = > {

console.log( ' ERROR ' , error);

});

A and B assume methods .error or .catch that don’t exist on typical event emitters.

C only catches synchronous errors from server.start(), not async event-based errors.

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 References (text-only)

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

Synchronous logs run immediately, before promise callbacks.

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

The File API in browsers provides the FileReader object to read file contents selected from < input type= " file " > .

Important knowledge points:

new FileReader() creates a file-reading object.

.readAsDataURL(file) reads a file and produces a Base64 URL string.

The " load " event fires when the file has finished reading.

reader.result contains the data URL after reading completes.

Therefore, the correct implementation must:

Create a FileReader instance:

const reader = new FileReader();

Call:

reader.readAsDataURL(file);

Use the load event handler to assign the image preview:

preview.src = reader.result;

Option B is the only option that matches valid JavaScript File API usage.

Option A is incorrect because File is not a constructor for reading files.

Option C is incorrect because URL.createObjectURL(file) must be assigned directly as a URL, not used with reader.result.

JavaScript Knowledge References (text-only)

The file-reading interface in browsers is FileReader.

readAsDataURL() loads files as Base64 data URLs.

The load event indicates when the reader has finished and reader.result is available.

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

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.

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

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)))

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.

We want to guarantee that the result is of type string regardless of what var1 and var2 are (numbers, booleans, etc.).

Option A:

String(var1).concat(var2)

String(var1) converts var1 explicitly to a string.

.concat(var2) calls String.prototype.concat, which:

Converts var2 to string if needed.

Returns a new string that is the concatenation of the two.

Result is always a string. So A is valid.

Option B:

String.concat(var1 + var2)

String.concat (as a static method) does not exist. concat is an instance method on string objects, not on the String constructor.

var1 + var2 might be a number (if both numeric) and used incorrectly here. So B is invalid.

Option C:

var1 + var2

+ can mean:

String concatenation (if at least one operand is a string).

Numeric addition (if both operands are numbers).

If var1 and var2 are both numbers, var1 + var2 will be a number, not a string.

This does not ensure the result is always a string. So C is not guaranteed to satisfy the requirement.

Option D:

var1.toString() + var2.toString()

var1.toString() converts var1 to a string (for most primitive/object types).

var2.toString() does the same.

Now both operands of + are strings, so the result is string concatenation.

Result is guaranteed to be a string. So D is valid.

Therefore, the two valid ways are A and D.

Study Guide / Concept References (no links):

String() conversion vs .toString()

String.prototype.concat

+ operator overload: numeric addition vs string concatenation

Type coercion rules for primitives

In Node.js:

__filename is the absolute path to the current file (including file name).

__dirname is the absolute path to the directory that contains the current file.

window.location is a browser-only global, not available in Node.js.

this.path is not a standard Node.js global for path information.

The requirement is:

“the folder location that the code executes from.”

That is exactly what __dirname provides.

So the correct choice is __dirname.

Concepts: Node.js globals, __filename, __dirname, Node vs browser environment.

We start with:

let productSKU = ' 8675309 ' ;

The requirement:

Final SKU string:

Length: 19 characters.

Starts with ' sku ' .

Remaining characters are digits padded with zeros on the left (to reach total length).

We can use String.prototype.padStart and String.prototype.padEnd:

str.padStart(targetLength, padString)

If str.length < targetLength, it adds padString to the start until the length is targetLength.

str.padEnd(targetLength, padString)

Similar, but adds padString to the end.

We want a pattern like:

First, pad the numeric part out to a fixed length with zeros.

Then, pad to total length with ' sku ' at the start.

Analyze Option B

productSKU = productSKU.padStart(16, ' 0 ' ).padStart(19, ' sku ' );

Step 1: productSKU.padStart(16, ' 0 ' )

Initial productSKU is ' 8675309 ' (length 7).

After padStart(16, ' 0 ' ), we pad zeros on the left to reach length 16.

We need 16 − 7 = 9 zeros:

Result after step 1:

productSKU === ' 0000000008675309 ' // length 16

Step 2: .padStart(19, ' sku ' )

Now productSKU has length 16.

We call padStart(19, ' sku ' ):

We need 19 − 16 = 3 extra characters.

The pad string ' sku ' is exactly 3 characters, so it is added as-is at the start.

Result after step 2:

productSKU === ' sku0000000008675309 ' // length 19

This satisfies:

Length 19.

Starts with ' sku ' .

Remaining characters are zeros plus the original digits, i.e. a zero-padded numeric section.

While the literal sample sku000000008675309 in the text has a slightly different count of zeros, Option B follows the requirement pattern:

3 characters of ' sku '

Numeric part padded with zeros to make 16 characters total for the numeric part

3 + 16 = 19 total characters

Option B matches the intended logic using padStart and padEnd.

Why the other options are incorrect

Option A:

productSKU = productSKU.padEnd(16, ' 0 ' ).padStart( ' sku ' );

padEnd(16, ' 0 ' ) produces ' 8675309000000000 ' (original number followed by zeros).

padStart( ' sku ' ) is invalid usage:

padStart takes a numeric target length as the first argument, not a string.

Passing ' sku ' as the first argument leads to type coercion that does not achieve the intended behavior.

This will not reliably produce the desired SKU.

Option C:

productSKU = productSKU.padEnd(16, ' 0 ' ).padStart(19, ' sku ' );

First padEnd(16, ' 0 ' ) from ' 8675309 ' gives ' 8675309000000000 ' (length 16, zeros at the end).

Then padStart(19, ' sku ' ) adds 3 chars ' sku ' at the front:

Result: ' sku8675309000000000 ' .

This string starts with ' sku ' , but the zeros are at the end of the digits, not padding the numeric part on the left as desired.

Option D:

productSKU = productSKU.padStart(19, ' 0 ' ).padStart( ' sku ' );

First padStart(19, ' 0 ' ) pads zeros at the left to make the length 19.

Then padStart( ' sku ' ) again incorrectly uses a string where a numeric targetLength is required.

This will not produce the correct SKU format.

Therefore, the only option that correctly uses padStart to create a 16-character zero-padded numeric portion and then a 19-character string starting with ' sku ' is:

Answer: B

References / Study Guide concepts (no links):

String.prototype.padStart(targetLength, padString)

String.prototype.padEnd(targetLength, padString)

String length calculations

Left-padding numeric strings with zeros

Building prefixed identifiers with fixed total length