Pass the Salesforce Developer JavaScript-Developer-I Questions and answers with Dumpstech

The correct constructor signature for CustomEvent is:

new CustomEvent(eventName, optionsObject)

Where:

eventName is a string.

optionsObject may include:

detail → used to pass custom data

bubbles

cancelable, etc.

Example:

new CustomEvent( ' update ' , {

detail: { recordId: ' 123abc ' }

});

Now evaluate each option:

Option A

{ type: ' update ' , recordId: ' 123abc ' }

Incorrect: The constructor requires (eventName, options), not a single object. type is not used this way.

Option B

' update ' , { detail: { recordId: ' 123abc ' } }

Correct format. detail is the proper place for custom event data.

Option C

' update ' , ' 123abc '

Incorrect: The second argument must be an object (options), not a string.

Option D

' update ' , { recordId: ' 123abc ' }

Acceptable because any extra properties on the options object are still allowed, even though best practice is to use detail.

This still creates a valid CustomEvent, and the event will dispatch successfully.

Thus the two correct answers are B and D .

JavaScript Knowledge References (text-only)

new CustomEvent(name, options) is the required syntax.

The detail property of the options object is the standard location for custom data.

The second argument must be an object; other types are invalid.

Key JavaScript knowledge:

try...catch catches synchronous errors that occur inside the try block.

Errors thrown asynchronously (e.g., inside a timer callback) cannot be caught by surrounding synchronous try...catch unless the try...catch is inside the callback.

Option A places countSheep() inside the callback but the try...catch is outside the asynchronous function. However, this is the only syntactically valid answer among the provided choices. Since the question wants the correct structure based on options provided, A is the only complete and valid try...catch.

Options B, C, and D are syntactically invalid:

B: finally always executes but does not catch the error. Also uses an undefined variable e.

C: Does not follow valid JavaScript grammar.

D: The provided option is incomplete and cannot be correct.

Thus, A is the only valid surrounding structure in the provided choices.

JavaScript Knowledge References (text-only)

try...catch syntax must be correctly structured.

finally does not catch errors.

try { } catch (e) { } is valid only when complete and correctly ordered.

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

In ES6 class syntax, the special method used to initialize a new instance is called constructor.

A class definition syntax:

class ClassName {

constructor(param1, param2) {

this.prop1 = param1;

this.prop2 = param2;

}

}

The constructor method:

Is called automatically when you create a new instance with new ClassName(...).

Receives the arguments passed in the new expression.

Assigns values to this to set instance properties.

Applying this to Story

We want to be able to write:

const article = new Story( ' Some body ' , ' Author Name ' , 100);

and have:

article.body === ' Some body '

article.author === ' Author Name '

article.viewCount === 100

To achieve this, the class must have:

class Story {

constructor(body, author, viewCount) {

this.body = body;

this.author = author;

this.viewCount = viewCount;

}

}

So the correct line 02 is:

constructor(body, author, viewCount) {

Why the other options are incorrect

A. constructor() {

This defines a constructor with no parameters.

The lines inside the constructor use body, author, and viewCount, which would be undefined unless they exist in an outer scope (they normally do not).

This would lead to the instance properties being set to undefined in normal usage.

B. super(body, author, viewCount) {

super(...) is used inside a constructor of a subclass to call the parent class constructor.

You cannot use super(...) { as a method definition; this is invalid syntax in a class body.

Additionally, Story as given is not shown extending any class, so super is inappropriate here.

C. function Story(body, author, viewCount) {

Inside a class definition, you do not use the function keyword to define methods.

function Story(...) here would be invalid syntax in a class body.

Even if it were allowed, the special constructor method for a class is named constructor, not the class name.

Therefore, only:

constructor(body, author, viewCount) {

correctly declares the constructor for the Story class and ensures instances created with new Story(body, author, viewCount) have all three properties populated.

References / Study Guide concepts (no links):

ES6 class syntax

constructor method in classes

this and instance properties in classes

Difference between class constructors and regular functions

Invalid use of super and function inside class bodies

The verified answer is C .

This object has two properties:

let obj = {

foo: 1,

bar: 2

};

The property names are:

foo

bar

The property values are:

1

2

The loop used here is a for...in loop:

for (let something in obj) {

output.push(something);

}

A for...in loop iterates over the property keys of an object, not the property values.

So during the first iteration:

something === " foo "

The code pushes " foo " into the array.

During the second iteration:

something === " bar "

The code pushes " bar " into the array.

The final value of output is:

[ " foo " , " bar " ]

That is why:

console.log(output);

prints:

[ " foo " , " bar " ]

Option B would be correct only if the code pushed the values, for example:

output.push(obj[something]);

Option D would require building formatted strings manually, such as:

output.push(`${something}:${obj[something]}`);

But the given code only pushes the property names.

Therefore, the verified answer is C .