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

Behavior of non-strict global code The script does not begin with a ' use strict ' directive at the top level, so the global code (outside any function) runs in non-strict (sloppy) mode.

Line 01: x = 3.14; In non-strict mode, assigning to an undeclared identifier (no var, let, or const) creates an implicit global variable. So after line 01, x exists and equals 3.14.

Line 08: z = x; This also runs in non-strict mode. Since x is already defined (from line 01), z is set to 3.14. Therefore, statement B is correct: z is equal to 3.14.

Scope of ' use strict ' inside a function The line:

' use strict ' ;

inside myFunction is a directive prologue for that function, not for the entire file. This means:

Strict mode applies only within the body of myFunction , from the directive to the end of that function.

It does not retroactively affect code before the function or code outside of it.

Therefore:

Statement A is incorrect: ' use strict ' is not “hoisted” to affect the whole file. It only affects the function body.

Statement C is incorrect: strict mode does not apply from line 04 to the end of the file; it only applies within myFunction, not to global lines like 01, 08, or 09.

Execution of myFunction in strict mode When myFunction is called on line 09:

function myFunction() {

' use strict ' ;

y = x;

}

Within this function:

Strict mode is active for its body.

In strict mode, assigning to an undeclared variable (like y here) is not allowed and results in a ReferenceError at runtime.

So line 05:

y = x;

throws a ReferenceError because y is not declared with var, let, or const.

Therefore, statement E is correct: line 05 throws an error.

Why statement D is considered correct Statement D says: ' use strict ' has an effect only on line 05.

In terms of execution in this specific code:

The only executable statement in myFunction that is affected by strict mode is the assignment on line 05.

The directive itself on line 04 is not a “normal” runtime operation; it is a directive that sets the mode.

There are no other statements inside the function that behave differently under strict mode; only the line that assigns to the undeclared variable shows a strict-mode effect.

So, describing the practical execution behavior of this snippet, strict mode manifests its effect only on line 05, making statement D correct in this context.

Summary of each option:

A: Incorrect – strict does not apply to all lines in the file.

B: Correct – z becomes 3.14 in non-strict global code.

C: Incorrect – strict does not affect code outside the function.

D: Correct – in this code, the only behavioral effect of strict mode is on line 05.

E: Correct – line 05 throws a ReferenceError due to assignment to undeclared y under strict mode.

JavaScript knowledge references (descriptive, no links):

In non-strict (sloppy) mode, assigning to an undeclared identifier creates a global variable.

' use strict ' inside a function body enables strict mode for that function only.

In strict mode, assigning to an undeclared variable results in a ReferenceError.

Directive prologues ( ' use strict ' ) affect only their containing function or script, not other scopes.

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

The question specifies:

The library “uses events and callbacks to start the server”.

We want to “set up an event and start the web server”.

Option C:

server((port) = > { console.log( ' Listening on ' , port); });

This:

Calls server(...), which (by design in such libraries) typically starts the web server.

Passes a callback function that receives port when the server is ready.

Inside the callback, it logs " Listening on < port > " .

This matches the “events and callbacks” description: the callback is invoked when the server has started listening.

Why others are incorrect:

A. server.on( ' connect ' , ...)

Assumes server is an event emitter instance with a ' connect ' event, which is not given. Also, this line alone would not start the server.

B. server.start();

Assumes a start method exists; the question says the library “uses events and callbacks to start,” implying invocation with a callback, not a plain start() call.

D. server();

Might start the server, but does not “set up an event” or callback to know when or where it is listening.

Therefore, C aligns with the described usage.

Concepts: callback-based APIs, starting servers with callbacks, event/callback style vs simple method calls.

The correct answers are B and D .

A strong test case checks whether the actual output matches the expected behavior of the function.

For Option B :

let res = fizzbuzz(15);

console.assert(res === ' fizzbuzz ' );

The number 15 is divisible by both 3 and 5:

15 % 3 === 0

15 % 5 === 0

So the correct return value is:

' fizzbuzz '

That makes option B a valid test.

For Option D :

let res = fizzbuzz(Infinity);

console.assert(res === ' ' );

Infinity is not a normal finite divisible number. In JavaScript:

Infinity % 3

Infinity % 5

produce NaN, and comparisons such as:

Infinity % 3 === 0

are false.

So a typical fizzbuzz implementation would not treat Infinity as divisible by 3 or 5, meaning it should return:

' '

That makes option D a valid test for the “neither divisible by 3 nor 5” path.

Now compare the incorrect options:

Option A is wrong because:

fizzbuzz(3)

should return:

' fizz '

not:

' buzz '

Option C is wrong because the function specification says the function returns strings such as ' fizz ' , ' buzz ' , ' fizzbuzz ' , or ' ' . It does not say the function returns numeric NaN.

So this assertion is not appropriate:

console.assert(isNaN(res));

Therefore, the verified answers are B and D .

The correct answers are C and D .

Arrays in JavaScript are objects. When an array variable is assigned directly to another variable, both variables point to the same array in memory.

Option C is correct:

let arr2 = arr;

This does not create a new array. It creates another reference to the same array.

Example:

arr2.push(6);

console.log(arr);

Output:

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

Changing arr2 also affects arr because both variables reference the same array.

Option D is also correct:

let arr2 = arr.sort();

The sort() method sorts the array in place and returns the same array reference. Therefore, arr2 refers to the same array object as arr.

The incorrect options create copies:

let arr2 = arr.slice(0, 5);

creates a shallow copy.

let arr2 = Array.from(arr);

also creates a new shallow copy.

So the two lines that make arr2 reference the original arr are C and D .

Recall:

NaN stands for “Not-a-Number”.

Arithmetic involving non-numeric values that cannot be converted to numbers often results in NaN.

Check each:

A. 10 / 0

In JavaScript, dividing a positive number by 0 results in Infinity, not NaN.

So this logs Infinity.

B. parseInt( ' two ' )

parseInt tries to parse a numeric prefix from the string.

' two ' does not start with numeric digits, so parseInt( ' two ' ) returns NaN.

The console log prints NaN.

C. 10 / Number( ' 5 ' )

Number( ' 5 ' ) → 5.

10 / 5 → 2.

Logs 2, not NaN.

D. 10 / ' five '

' five ' is coerced to a number using Number( ' five ' ), which is NaN.

10 / NaN → NaN.

Logs NaN.

So the console logs that output NaN are from B and D.

Relevant concepts: NaN, Infinity, parseInt, Number() coercion, arithmetic with invalid numeric values.

The correct answer is C .

The browser provides the History API through:

window.history

To add a new entry to the browser’s session history without refreshing the page, JavaScript uses:

window.history.pushState(state, title, url);

So the valid statement is:

window.history.pushState(newStateObject, ' ' , null);

This updates the browser history stack without forcing a full page reload. It is commonly used in single-page applications when changing views or routes dynamically.

The method accepts three arguments:

window.history.pushState(stateObject, title, url);

stateObject stores custom data associated with the history entry.

title is usually passed as an empty string because many browsers ignore it.

url optionally changes the displayed URL. Passing null means no new URL is provided.

Option A is incorrect because:

window.customHistory

is not the standard browser History API object.

Option B is incorrect because:

createState()

is not a valid History API method.

Option D is incorrect because:

updateState()

is not a valid History API method.

The correct browser API method is:

window.history.pushState()

Therefore, the verified answer is C .

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

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.

The correct answer is D .

Semantic versioning usually follows this format:

MAJOR.MINOR.PATCH

For the version:

1.1.3

The parts are:

1 = MAJOR

1 = MINOR

3 = PATCH

A package version should be updated based on the type of change:

MAJOR version changes when there are breaking changes.

MINOR version changes when new features are added in a backward-compatible way.

PATCH version changes when backward-compatible bug fixes are added.

The question says the developer added new features that do not break backward compatibility . That means the minor version should increase.

Starting version:

1.1.3

Increase the minor version from 1 to 2, and reset the patch version to 0:

1.2.0

Why the other options are incorrect:

A. 1.2.3 is incorrect because when the minor version increases, the patch version should reset to 0.

B. 1.1.4 is incorrect because that would represent a patch update, usually for bug fixes, not new features.

C. 2.0.0 is incorrect because that would represent a major version update, usually for breaking changes.

D. 1.2.0 is correct because it represents a backward-compatible feature release.

Therefore, the verified answer is D .

Execution order:

Top-level code runs synchronously:

Line 14: console.log(4); → logs 4.

Line 15: callDelay(); is called.

Inside callDelay:

Line 9: console.log(2); → logs 2.

Line 10: await delay(1000);:

Calls delay(1000).

Inside delay(1000):

Line 3: console.log(1); → logs 1.

Line 4: setTimeout(resolve, delay); schedules resolve in 1000 ms.

delay returns a pending Promise. await pauses callDelay here and returns control to the event loop.

Back to top-level:

Line 16: console.log(5); → logs 5.

So synchronous log sequence is: 4, 2, 1, 5.

After ~1000 ms:

The setTimeout in delay resolves the Promise.

The await in callDelay resumes.

Line 11: console.log(3); → logs 3.

Final log order: 4 2 1 5 3.

Both A and B show the same sequence; one must be chosen, so A is correct.

Concepts: async/await flow, Promise resolution timing, event loop, and ordering of synchronous vs timer callbacks.