Important Salesforce JS-Dev-101 Exam Questions

Answer: A, C

Explanation:

Comprehensive and Detailed Explanation From Exact Extract JavaScript Knowledge:

Browsers often cache JavaScript, CSS, and HTML. This means:

The developer may be running with the latest version (often with cache disabled in DevTools).

The tester may still be loading an older, cached version of the page where the background-change logic does not exist.

To ensure they are actually testing the latest deployed code:

Disabling cache (A) in the tester's browser (usually via DevTools Network ''Disable cache'') forces fresh loading of all resources on each refresh.

Clearing cache (C) removes older resources from the browser so the next load fetches fresh files from the server.

Options B and D do not directly help verify the tester is using the latest code:

B checks the developer's own browser, which is not the environment showing the problem.

D suggests reworking the code before confirming whether the tester is actually loading the correct version, which is premature.

So the two actions that help produce accurate testing results are A and C.

________________________________________

Answer: B

Explanation:

If the dependency was added as a dev dependency (yarn add --dev), it goes into devDependencies.

When NODE_ENV=production, Yarn (and npm) typically skip devDependencies on install.

Thus the package doesn't get installed for other team members in a production environment.

YARN_ENV is not a standard variable, --save is npm syntax (and Yarn saves by default), and --add is not how Yarn works (the command itself is yarn add).

________________________________________

Answer: A, B

Explanation:

________________________________________

Comprehensive and Detailed Explanation From Exact Extract JavaScript Knowledge

There are two valid ways to ensure leo.roar() exists:

Directly assign a roar function to leo (Option A).

Assigning a property to an instance object creates a new method on that instance.

leo.roar = () => { console.log('They\'re pretty good!'); };

After this, calling leo.roar() is valid.

Copy tony's properties into leo using Object.assign (Option B).

Object.assign(target, source) copies enumerable own properties from the source object into the target object.

Since tony.roar exists, executing:

Object.assign(leo, tony);

copies roar into leo, making leo.roar() valid.

Why the other answers are incorrect:

Option C:

Object.assign(leo, Tiger) copies properties from the function object Tiger, not from Tiger.prototype and not from a Tiger instance. Tiger (the function) has no roar property, so nothing useful is copied.

Option D:

leo.prototype is undefined because leo is an instance, not a constructor function. Only constructor functions have a .prototype property. This line would cause an error.

________________________________________

JavaScript Knowledge Reference (text-only)

Instances have their own properties and do not contain a .prototype property.

Object.assign(target, source) copies own enumerable properties of the source object.

Assigning a function as a property of an object creates a callable method.

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

Answer: A, D

Explanation:

Comprehensive and Detailed Explanation From Exact Extract JavaScript knowledge:

We start with the array:

let inArray = [ [1, 2], [3, 4, 5] ];

This is an array of two inner arrays:

First element: [1, 2]

Second element: [3, 4, 5]

The desired result is to transform this into a single, flat array:

[1, 2, 3, 4, 5]

This is accomplished by using Array.prototype.concat to concatenate the inner arrays into one new array, optionally combined with the spread syntax (...) or Function.prototype.apply.

Option A: [].concat(...inArray);

Relevant concepts:

Spread syntax (...inArray) expands an iterable into separate arguments.

Array.prototype.concat joins arrays or values into a new array. When you pass arrays as arguments to concat, it flattens them one level into the result.

Step-by-step behavior:

inArray is [ [1, 2], [3, 4, 5] ].

...inArray expands into [1, 2] and [3, 4, 5] as separate arguments.

So [].concat(...inArray) is equivalent to:

[].concat([1, 2], [3, 4, 5]);

concat processes each argument:

For [1, 2], it adds 1 and 2 into the result array.

For [3, 4, 5], it adds 3, 4, and 5 into the result array.

The final outcome is:

[1, 2, 3, 4, 5]

Therefore, Option A correctly produces the desired array.

Option B: [].concat.apply(inArray, []);

Corrected name from usArray to inArray.

Relevant concepts:

Function.prototype.apply(fnThis, argsArray) invokes a function with a specific this value and a list of arguments passed as an array.

Here:

thisArg is inArray.

argsArray is [] (no actual arguments passed).

So the call:

[].concat.apply(inArray, []);

is equivalent to:

Array.prototype.concat.apply(inArray, []);

// i.e. inArray.concat();

Since there are no extra arguments, inArray.concat() simply returns a shallow copy of inArray:

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

This remains an array of arrays and is not flattened into [1, 2, 3, 4, 5]. Therefore, Option B does not produce the required result.

Option C: [].concat::...inArray();

Corrected name from usArray to inArray and .. to ....

This expression uses syntax that is not part of standard JavaScript:

:: (double colon) was proposed in early drafts as a bind operator but is not part of the official ECMAScript standard.

The combination concat::...inArray() is invalid in normal JavaScript engines and cannot be used as a valid way to flatten arrays.

In addition, inArray() would imply calling inArray as a function, but it is an array, which would cause a runtime error.

Hence, Option C is syntactically or semantically invalid in standard JavaScript and does not provide the required result [1, 2, 3, 4, 5].

Option D: [].concat.apply({}, inArray);

Corrected name from usArray to inArray.

Relevant concepts:

Again, Function.prototype.apply is used to call concat with a specific this value and arguments provided as an array.

concat treats its this value as an array-like object but ultimately returns a new array containing concatenated elements.

In this expression:

[].concat.apply({}, inArray);

thisArg is {} (an empty object).

argsArray is inArray, which is [ [1, 2], [3, 4, 5] ].

Using apply, this is interpreted as calling concat like:

Array.prototype.concat.call({}, [1, 2], [3, 4, 5]);

concat then:

Starts from the array-like this (here {} is treated as an empty base).

Takes the first argument [1, 2] and appends its elements 1 and 2 to the result.

Takes the second argument [3, 4, 5] and appends its elements 3, 4, and 5 to the result.

The resulting new array is:

[1, 2, 3, 4, 5]

Therefore, Option D also correctly produces the required array.

Final evaluation of all options:

Option A: Uses spread syntax with concat and correctly flattens one level: [1, 2, 3, 4, 5].

Option B: Equivalent to inArray.concat(), leaving it as [[1, 2], [3, 4, 5]]. Does not flatten the structure.

Option C: Uses non-standard and invalid syntax; not a valid or correct JavaScript solution.

Option D: Uses apply with concat, passing the inner arrays as arguments and flattening one level to [1, 2, 3, 4, 5].

Thus, the two correct statements are:

Reference of JavaScript knowledge documents or Study Guide (concept names only):

Array.prototype.concat (concatenating and one-level flattening behavior)

Spread syntax for arrays (...array)

Function.prototype.apply (calling a function with a given this value and arguments list)

Array flattening by one level using concat with array arguments

Distinction between nested arrays and flat arrays in JavaScript

Answer: C, D, E

Explanation:

When pet1 = new Pet(); is created:

Inside Pet constructor:

Animal.call(this, size, type);

this.size = size;

this.name = name;

this.owner = owner;

Animal.call(this, size, type):

Sets this.type = type || 'Animal' 'Animal' (because type is undefined).

Sets this.canTalk = false.

Then this.size, this.name, this.owner are set (to undefined since no args passed), but they do exist as properties.

So as own properties, pet1 has: type, canTalk, size, name, owner.

speak is defined on Animal.prototype, so pet1.speak exists by inheritance, but is not an own data property created in the constructor.

From the listed options, three important properties directly set by constructor logic and clearly used in behavior are:

canTalk

name

type

Thus, C, D, E.

________________________________________