Salesforce JavaScript-Developer-I - Salesforce Certified JavaScript Developer (JS-Dev-101)

The correct answer is B because variable a is declared and initialized before it is printed.

let a = " * " ;

This creates a block-scoped variable named a and assigns it the string value:

" * "

The line:

// x = 3;

is a comment. JavaScript ignores comments during execution, so this line has no effect.

Then this line runs:

console.log(a);

Since a already exists and contains " * " , the console displays:

*

Option A is incorrect because a is defined.

Option C is incorrect because a has an assigned value, so it is not undefined.

Option D is incorrect because a was never assigned null.

Therefore, the verified answer is B .

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

We have an array of plain objects:

[

{ name: ' John ' , email: ' john@email.com ' },

{ name: ' Jane ' , email: ' jane@email.com ' },

{ name: ' Emily ' , email: ' emily@email.com ' }

]

We want:

A “visual representation” of the list.

Ability to sort by name or email in DevTools.

console.table:

console.table(data) renders data as a table in most browser devtools and Node consoles that support it.

Each object becomes a row; properties (name, email) become columns.

Many DevTools UIs allow:

Clicking column headers to sort by that column.

Filtering / viewing in a structured way.

So:

console.table(usersList);

Displays a sortable table of users by name or email. This matches the requirement exactly.

Other options:

console.group(usersList);

Starts a console group. The argument is just logged as a line label.

It does not create a table or sortable view; it just groups subsequent logs.

console.groupCollapsed(usersList);

Same grouping behavior, but collapsed by default.

Again, no table or sortable columns.

console.info(usersList);

Logs the array in the console, but as a standard log/info.

You can expand objects, but there is no table view or built-in column sorting.

Therefore, the correct method is:

Answer: A

Study Guide / Concept References (no links):

console.table for tabular logging

console.group and console.groupCollapsed for grouped logs

console.log / console.info standard logging behavior

DevTools UI support for sorting columns in console.table

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.

Behavior of Promise.prototype.finally:

.finally(handler) registers a callback that runs when the promise is settled , meaning:

Either fulfilled (resolved) , or

rejected .

Important points:

The finally callback does not receive the promise’s value or error (unlike then and catch).

It is executed after the promise is settled, but before the resolution value or rejection reason is passed further down the chain.

It runs in both success and failure paths.

In the given code:

The promise may either:

Call reject( ' fraction > 0.5, ' + fraction) if fraction > 0.5, or

Call resolve(fraction) otherwise.

In both cases:

If it resolves , .then(() = > console.log( ' resolved ' )) runs, and then .finally(...) is executed.

If it rejects , .catch((error) = > console.error(error)) runs, and then .finally(...) is executed.

So .finally runs:

Not just “when rejected”.

Not just “when resolved”.

But whenever the promise is resolved or rejected .

Therefore, the correct choice is:

D. When resolved or rejected .

JSON.stringify() applies the following rules:

String objects (new String( ' false ' )) Are converted to their primitive string values . So:

new String( " false " ) → " false "

Boolean objects (new Boolean(false)) Convert to their primitive boolean value :

new Boolean(false) → false

Undefined values inside arrays According to the JSON specification, undefined becomes null when stringifying an array:

JSON.stringify([undefined]) → " [null] "

Therefore, the array becomes:

[ " false " , false, null]

And JSON.stringify wraps it in quotes:

' [ " false " , false, null] '

This is exactly option A.

JavaScript Knowledge References (text-only)

Object wrappers (String, Boolean) are converted to primitives during JSON serialization.

undefined becomes null inside arrays when stringified.

JSON.stringify() follows the JSON data-model rules strictly.

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

Initial array:

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

The loop removes every value equal to 4:

array.splice(i, 1) removes the element at index i and shifts all later elements left.

i-- ensures the next index is checked correctly after the shift, preventing skipping elements.

Step-by-step removal:

Remove the first 4 → array becomes [1,2,3,4,5,4,4]

Remove next 4 → [1,2,3,5,4,4]

Remove next 4 → [1,2,3,5,4]

Remove last 4 → [1,2,3,5]

Final result:

[1,2,3,5]

Option B is correct.

JavaScript Knowledge References (text-only)

splice(index, deleteCount) removes elements and shifts remaining items.

Adjusting the loop index when deleting prevents skipping items.

Arrays update length dynamically after splice().

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 .

1. Getter Functions in JavaScript

In JavaScript, when an object uses the get keyword, it defines a getter method . Accessing a getter property executes the function and returns its value. Thus:

o.js

does not return the getter function; instead, it executes the function located at:

get js() { ... }

and returns the object inside the return block.

2. Behavior of String() and toLowerCase()

Inside the getter:

let city1 = String( ' St. Louis ' );

let city2 = String( ' New York ' );

String() creates a string value.

Then, the returned object is constructed as:

{

firstCity: city1.toLowerCase(),

secondCity: city2.toLowerCase(),

}

The method toLowerCase() is a standard JavaScript string method that returns a new string with all alphabetic characters converted to lowercase .

Therefore:

city2.toLowerCase()

returns:

' new york '

3. Referencing the Property

When the developer writes:

o.js.secondCity

the following happens:

The getter js runs and returns an object.

The returned object includes the property:

secondCity: ' new york '

Accessing .secondCity retrieves the lowercase string ' new york ' .

Therefore, the correct value is ' new york ' .

Why the Other Options Are Incorrect

A. undefined – incorrect because the property secondCity clearly exists in the returned object.

B. An error – incorrect because no invalid operations occur; all methods and properties are valid.

C. ' New York ' – incorrect because toLowerCase() transforms the string to lowercase.

JavaScript Knowledge References (Text-Based)

Getter methods using the get keyword return computed values when accessed.

JavaScript String values support the toLowerCase() method, which returns a lowercase version of the original string.

Accessing nested properties like o.js.secondCity triggers the getter, returning the constructed object.

The correct answer is B .

This question is about the event-driven programming model commonly used in Node.js. Many Node.js libraries expose an .on() method to register callback functions for specific events.

The correct pattern is:

ws.on( ' eventName ' , callbackFunction);

In this case, the developer needs to listen for two events:

' connect '

and:

' error '

The correct implementation is:

ws.on( ' connect ' , () = > {

console.log( ' Connected to client ' );

});

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

console.log( ' ERROR ' , error);

});

This registers one listener for successful connection and another listener for connection errors.

Why this works professionally:

ws.on( ' connect ' , callback) tells the library:

“When the connection event happens, execute this callback.”

ws.on( ' error ' , callback) tells the library:

“When an error event happens, execute this callback and pass the error object into it.”

Option A is incorrect because .catch() is used with Promises. The question specifically says the client library is built using events and callbacks , not Promise chaining.

Option D is incorrect because try...catch only catches synchronous errors during the immediate execution of ws.connect(). It will not reliably catch asynchronous connection errors emitted later by the web socket client.

Option C is identical to option B in the provided question. Since the expected answer normally requires selecting one option, B is selected as the verified answer.

Therefore, the verified answer is B .