Free Practice Questions for Salesforce JavaScript-Developer-I Exam

Node.js provides two built-in modules for creating servers:

http → creates non-secure HTTP servers

https → creates secure HTTPS servers

A secure server requires:

SSL/TLS certificates (key and cert)

The built-in Node.js module designed to handle these: https

Syntax for a secure server:

const https = require( ' https ' );

const fs = require( ' fs ' );

const options = {

key: fs.readFileSync( ' key.pem ' ),

cert: fs.readFileSync( ' cert.pem ' )

};

https.createServer(options, (req, res) = > {

res.write( ' Secure Server ' );

res.end();

}).listen(443);

Evaluation of options:

A is incorrect: No built-in module named secure-server exists.

B is incorrect: tls provides low-level TLS sockets, not HTTP/HTTPS servers.

C is incorrect: http only creates an insecure server.

D is correct: https is the built-in module required for secure web servers.

JavaScript Knowledge References (text-only)

Node.js exposes built-in modules http and https for server creation.

Secure servers require the https module, which supports TLS/SSL.

The tls module is lower-level and not used for full HTTP servers.

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

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.

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 .

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.