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

Person.proto is being set, but JavaScript uses Person.prototype for the prototype chain, not Person.proto.

Therefore, job is not on Person.prototype, and instances of Person do not have job via prototype.

myFather is created with new Person(), so:

myFather.firstName is ' John ' .

myFather.job is undefined.

Attempting to call myFather.job() results in:

TypeError: myFather.job is not a function

So option A is correct.

The verified answer is A .

This constructor function runs when new Person() is called:

function Person() {

this.firstName = " John " ;

}

So this line:

const myFather = new Person();

creates an object like this:

{

firstName: " John "

}

Then the prototype is assigned a method named job:

Person.prototype = {

job: x = > " Developer "

};

Because myFather is created from Person, it can access properties and methods from Person.prototype.

So:

myFather.firstName

returns:

" John "

And:

myFather.job()

returns:

" Developer "

Therefore:

const result = myFather.firstName + " " + myFather.job();

becomes:

const result = " John " + " " + " Developer " ;

Final value:

" John Developer "

Option B is incorrect because job() returns " Developer " , not undefined.

Option C is incorrect because job exists on Person.prototype, so it is callable.

Option D is incorrect because firstName is assigned inside the constructor.

Therefore, the verified answer is A .

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 A, C, and E .

Node.js allows JavaScript to run outside the browser. That makes it useful for backend development, command-line tools, APIs, real-time applications, and server-side services.

A is correct because Node.js executes JavaScript on the server side.

A team that already knows:

HTML

CSS

JavaScript

can use JavaScript for backend development as well. This reduces the need to switch to a completely different backend language.

Example:

const http = require( ' http ' );

const server = http.createServer((req, res) = > {

res.end( ' Hello from Node.js ' );

});

server.listen(3000);

This is server-side JavaScript.

C is correct because Node.js uses a non-blocking, event-driven model.

For API servers, this is valuable because Node.js can handle many I/O operations without blocking the entire process while waiting for tasks like:

database queries

file reads

network requests

API responses

Instead of waiting synchronously, Node.js can register callbacks, promises, or async functions and continue handling other work.

E is correct because Node.js commonly installs with npm, the Node Package Manager.

npm is used to install and manage third-party libraries, such as:

Express

Socket.IO

dotenv

Jest

Axios

This makes it easier to build backend applications using reusable packages.

Now review the incorrect answers:

B is incorrect because JavaScript is not primarily a static-analysis language by default. Node.js executes JavaScript at runtime. Static checking can be added with tools such as TypeScript, ESLint, or other analyzers, but that is not an inherent Node.js benefit.

D is incorrect because Node.js does not release one major version only every few years. Its release cycle is more frequent than that, so this is not an accurate benefit statement.

Therefore, the verified answers are A, C, and E .

The function:

async function functionUnderTest(isOK) {

if (isOK) return ' OK ' ;

throw new Error( ' not OK ' );

}

Behavior:

If isOK is true:

The function resolves (fulfills the promise) with value ' OK ' .

If isOK is false:

The function throws, which in an async function becomes a rejected promise with Error( ' not OK ' ).

We want an assertion that accurately tests the successful path for isOK === true.

Key points about console.assert:

Signature: console.assert(condition, message?)

If condition is falsy , it logs message as an assertion failure.

If condition is truthy , nothing is logged.

We also must understand await:

await functionUnderTest(true) will resolve to the string ' OK ' .

Now evaluate options.

Option A:

console.assert(await functionUnderTest(true), ' OK ' );

await functionUnderTest(true) → ' OK ' (truthy).

console.assert( ' OK ' , ' OK ' );

Condition is ' OK ' (truthy), so assertion passes.

The message ' OK ' is only shown if the condition is falsy, which it is not.

This correctly verifies that the promise resolved (i.e., did not reject). Among the given options, this is the only one that both:

Uses await properly on the async function, and

Associates the message with the expected success " OK " .

Option B:

console.assert(await (functionUnderTest(true), ' not OK ' ));

Inside the parentheses, the comma operator (a, b) evaluates a, discards it, and returns b.

So (functionUnderTest(true), ' not OK ' ):

Calls functionUnderTest(true) (returns a promise, but its result is discarded),

The expression evaluates to the string ' not OK ' .

Then await ' not OK ' just resolves to ' not OK ' immediately (not a promise).

console.assert( ' not OK ' );

Condition is ' not OK ' (truthy), so the assertion passes regardless of what functionUnderTest actually does.

This does not meaningfully test the function and is misleading.

Option C:

console.assert(functionUnderTest(true), ' OK ' );

functionUnderTest(true) returns a Promise , not the string ' OK ' directly.

A Promise object is always truthy.

So console.assert(promise, ' OK ' ) will pass, even if the promise later rejects.

Also, there is no await, so we are not actually waiting for the async result.

This is not a correct way to assert on an async function’s resolved value.

Option D:

console.assert(await functionUnderTest(true), ' not OK ' );

await functionUnderTest(true) still resolves to ' OK ' (truthy).

console.assert( ' OK ' , ' not OK ' ); passes.

However, the message ' not OK ' is the opposite of what we expect for the success case and is only used when the condition fails.

This makes the assertion logically inconsistent with the function behavior (it would show " not OK " if the assertion failed).

Therefore, the only assertion that:

Properly waits on the async function, and

Has expectation text that matches the successful behavior ( ' OK ' )

is:

Answer: A

Study Guide / Concept References (no links):

async and await behavior in JavaScript

Promises resolving vs rejecting in async functions

console.assert(condition, message) usage

Truthy and falsy values in JavaScript

Comma operator (a, b) semantics

Currently:

sayHello expects a value name and prints it.

world is a function that returns ' World ' .

sayHello(world); passes the function object itself, not the result of calling it.

So name inside sayHello is a function, not the string " World " .

To keep the call sayHello(world) yet get " World " , sayHello must call the function parameter:

const sayHello = (name) = > {

console.log( ' Hello ' , name());

};

Now:

sayHello(world) passes the function.

Inside sayHello, name() calls world(), which returns " World " .

The console logs " Hello World " .

Why the others are wrong:

B: Changing line 7 to }(); would attempt to IIFE the function definition and break the declaration.

C: sayHello(world)() would try to call the return value of sayHello, which is undefined, causing an error.

D: Changing world to a function declaration does not change the fact that it is passed as a function reference; sayHello still prints the function object, not ' World ' .

A subclass created by:

Console16bit.prototype = Object.create(GameConsole.prototype);

inherits all prototype methods from GameConsole, including load.

To override the inherited method, the correct syntax is to assign a new function to the method name on the prototype:

Console16bit.prototype.load = function(gamename) {

console.log(`${this.name} is loading a cartridge game: ${gamename}....`);

};

Why the other options are wrong:

A assigns something to the constructor function itself, not to the prototype method. Invalid.

B attempts to call a function in the left-hand side of an assignment; invalid syntax.

C also uses invalid syntax—prototype methods cannot be defined this way.

D is the correct definition of a prototype method override.

JavaScript Knowledge References (text-only)

Methods are overridden by assigning functions to Subclass.prototype.methodName.

Object.create() establishes prototype inheritance.

Constructor functions require prototype method attachment using assignment syntax.

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

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

setInterval(fn, delay, arg1, arg2, ...) calls fn every delay ms, passing extra arguments.

To call isDeg every 60 seconds with " cat " :

setInterval(isDeg, 60000, ' cat ' );

Why others are wrong:

A/D: isDeg( ' cat ' ) is called immediately, and its return value is scheduled, not the function.

C: setTimeout runs once after 60 seconds, not repeatedly.

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