Objects

Question 1

How to duplicate a json Safe object

Answer 1

var newObj = JSON.parse( JSON.stringify( someObj ) );

Question 2

How to do shallow copy in JS

Answer 2

var newObj = Object.assign( {}, myObject );

newObj.a; // 2
newObj.b === anotherObject; // true
newObj.c === anotherArray; // true
newObj.d === anotherFunction; // true)

Question 3

How to explicitly define a property on a object

Answer 3

var myObject = {};

Object.defineProperty( myObject, "a", {
	value: 2,
	writable: true,
	configurable: true,
	enumerable: true
} );

myObject.

Question 4

How to prevent new properties being added to a object

Answer 4

var myObject = {
	a: 2
};

Object.preventExtensions( myObject );

myObject.b = 3;
myObject.b;

Or
Object.seal(myObject)which internally calls Object.preventExtensions(myObject)

Or Object.freeze(myObject) which internally calls
Object.seal(..)

Question 5

what is [[Get]]

Answer 5

var myObj = {a:2}
myObj.a; // performs a [[Get]] operation on teh objec t to get the value of a

Question 6

How to check if a property exists in object

Answer 6

var myObject = {
	a: 2
};

//Checks teh prototype as well
("a" in myObject);				// true
("b" in myObject);				// false

//checks only the object, ignores the prototype chain
myObject.hasOwnProperty( "a" );	// true
myObject.hasOwnProperty( "b" );	// false

Question 7

What is teh output
var myObject = {a:10}
console.log(myObject.b)

Answer 7

undefined

Question 8

Explain Polymorphism in JS

Answer 8

Polymorphism in JS is rather Explicit and not Relative like Other languages.
Basically all properties of base class which arent in the derived are copied over by a some utility

JavaScript functions can’t really be duplicated (in a standard, reliable way), so what you end up with instead is a duplicated reference to the same shared function object (functions are objects; see Chapter 3). If you modified one of the shared function objects (like ignition()) by adding properties on top of it, for instance, both Vehicle and Car would be “affected” via the shared reference.

Question 9

What is [Prototype]

Answer 9

Objects in JavaScript have an internal property, denoted in the specification as [[Prototype]], which is simply a reference to another object. Almost all objects are given a non-null value for this property, at the time of their creation.

Question 10

how to check if an object has property built in itself

Answer 10

object.hasOwnproperty() method

Question 11

How to prototypically link two objects?

Answer 11

var obj1 = {a:2}
var obj2 = Object.create(obj1)
console.log(obj2.a)//2

Question 12

what is the output
var obj1 = {a:2}
var obj2 = Object.Create(obj1)
obj2.a=10
console.log(obj1.a)
console.log()obj2.a)

Answer 12

2

10

Question 13

what are the rules around setting a property on a prototypically linked object

Answer 13

If a normal data accessor (see Chapter 3) property named foo is found anywhere higher on the [[Prototype]] chain, and it’s not marked as read-only (writable:false) then a new property called foo is added directly to myObject, resulting in a shadowed property.
If a foo is found higher on the [[Prototype]] chain, but it’s marked as read-only (writable:false), then both the setting of that existing property as well as the creation of the shadowed property on myObject are disallowed. If the code is running in strict mode, an error will be thrown. Otherwise, the setting of the property value will silently be ignored. Either way, no shadowing occurs.
If a foo is found higher on the [[Prototype]] chain and it’s a setter (see Chapter 3), then the setter will always be called. No foo will be added to (aka, shadowed on) myObject, nor will the foo setter be redefined.

Question 14

What is the output?

function Foo(){
console.log("Hello")
}

var a = new Foo();

console. log(a.Constructor)
console. log(a.Constructor === Foo)

Answer 14

Foo
Constructor.

The constructor property gets sets on Foo’s prototype when the new keyword is used.

Question 15

what is the output?

function Foo() { /* .. */ }

Foo.prototype = { /* .. */ }; // create a new prototype object

var a1 = new Foo();

a1. constructor === Foo;
a1. constructor === Object;

Answer 15

false
true

fi you create a new object, and replace a function’s default .prototype object reference, the new object will not by default magically get a .constructor on it.

What’s happening? a1 has no .constructor property, so it delegates up the [[Prototype]] chain to Foo.prototype. But that object doesn’t have a .constructor either (like the default Foo.prototype object would have had!), so it keeps delegating, this time up to Object.prototype, the top of the delegation chain. That object indeed has a .constructor on it, which points to the built-in Object(..) function.

Question 16

Foo.prototype.isPrototypeOf( a );

what does this do?

Answer 16

The question isPrototypeOf(..) answers is: in the entire [[Prototype]] chain of a, does Foo.prototype ever appear?

Question 17

var a ={}
what is?
a.__proto__

Answer 17

Most browsers (not all!) have also long supported a non-standard alternate way of accessing the internal [[Prototype]]:. __proto__ points to the internal prototype object

Question 18

how do classes work in JS

Answer 18

Though there is class keyword and inheritance is possible, what actually happens is behaviour delegation.
When a class derives from another, it's actually the _prototype_ property which delegates the work to the base class.

Question 19

what is the output?
var a = {a:10}
var b = Object.Create(a)
b.b=10
a = Object.Create(b)

Answer 19

Circular references are disallowed in Javascript

Question 20

what does this do?

Button.prototype = Object.create( Widget.prototype );

Answer 20

// make Button “inherit” from Widget