Prototypes, inheritance, F.prototype

Question 1

The property _______is internal and hidden, but there are many ways to set it.

Answer 1

[[Prototype]]

Question 2

________ is a historical getter/setter for [[Prototype]]

Answer 2

__proto__

Question 3

__proto__ is the same as [[Prototype]]

TRUE / FALSE

Answer 3

__proto__ is not the same as [[Prototype]]

Question 4

Object.getPrototypeOf & Object.setPrototypeOf

replaced

Answer 4

__proto__ set and get

Question 5

let animal = {
  eats: true
};
let rabbit = {
  jumps: true
};

rabbit.__proto__ = animal; // (*)

// we can find both properties in rabbit now:
alert( rabbit.eats ); //
alert( rabbit.jumps ); //

Answer 5

true

true

Question 6

let animal = {
  eats: true,
  walk() {
    alert("Animal walk");
  }
};

let rabbit = {
  jumps: true,
  \_\_proto\_\_: animal
};

let longEar = {
earLength: 10,
__proto__: rabbit
};

longEar.walk(); //
alert(longEar.jumps); //

Answer 6

// walk is taken from the prototype chain
Animal walk
true // (from rabbit)

Question 7

The value of __proto__ can be either an_____ or ______, other types (like primitives) are ignored.

Answer 7

object

null

Question 8

The prototype is used for reading and writing properties

TRUE / FALSE

Answer 8

FLASE

The prototype is only used for reading properties

Question 9

this is not affected by prototypes at all

TRUE / FALSE

Answer 9

true

Question 10

No matter where the method is found: in an object or its prototype. In a method call, _______ is always the object before the dot.

Answer 10

“this”

Question 11

The for..in loops over inherited properties.

TRUE / FALSE

Answer 11

true

Question 12

The prototype is only used for _________ properties.

Answer 12

reading

Question 13

let animal = {
  walk() {
    if (!this.isSleeping) {
      alert(`I walk`);
    }
  },
  sleep() {
    this.isSleeping = true;
  }
};

let rabbit = {
name: “White Rabbit”,
__proto__: animal
};

rabbit.sleep();
alert(animal.isSleeping); //

Answer 13

undefined (no such property in the prototype)

Question 14

let animal = {
  eats: true
};

let rabbit = {
  jumps: true,
  \_\_proto\_\_: animal
};

alert(Object.keys(rabbit)); //

Answer 14

jumps

Question 15

let animal = {
  eats: true
};

let rabbit = {
  jumps: true,
  \_\_proto\_\_: animal
};

for(let prop in rabbit) alert(prop); //

Answer 15

jumps, then eats

Question 16

If that’s not what we want, and we’d like to exclude inherited properties, there’s a built-in method __________________ it returns true if obj has its own (not inherited) property named key.

Answer 16

obj.hasOwnProperty(key):

Question 17

Remember, new objects can be created with a _________ function.

Answer 17

constructor

Question 18

let animal = {
  eats: true
};

function Rabbit(name) {
  this.name = name;
}

Rabbit.prototype = animal;

let rabbit = new Rabbit(“White Rabbit”); // WRITE USING PROTO

alert( rabbit.eats ); // true

Answer 18

rabbit.__proto__ == animal

Question 19

let animal = {
  eats: true
};

function Rabbit(name) {
  this.name = name;
}

Rabbit.prototype = animal;

Answer 19

prototype

[[prototype]]

Question 20

The default “prototype” is an object with the only property__________ that points back to the function itself.

Answer 20

constructor

Question 21

function Rabbit() {}

/* default prototype
Rabbit.prototype = \_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_
*/

HINT: use constructor

Answer 21

{ constructor: Rabbit };

Question 22

function Rabbit() {}

/* default prototype
\_\_\_\_\_\_\_\_\_\_\_\_ = { constructor: Rabbit };
*/

HINT: use prototype

Answer 22

Rabbit.prototype

Question 23

function Rabbit() {}

// Rabbit.prototype = { constructor: Rabbit }

alert( __________________); // true

CHECK If RABBIT == constructor

Answer 23

Rabbit.prototype.constructor == Rabbit

Question 24

function Rabbit() {}

// Rabbit.prototype = { constructor: Rabbit }

let rabbit = new Rabbit(); // inherits from

Answer 24

{constructor: Rabbit}

Question 25

function Rabbit() {} // Rabbit.prototype = { constructor: Rabbit } alert(rabbit.constructor == Rabbit); // inherits from

Answer 25

(from prototype)

Question 26

function Wabbit() {} }; ``` let rabbit = new Wabbit(); alert(rabbit.constructor === Wabbit); // ``` TRUE / FLASE

Answer 26

TRUE

Question 27

``` function Rabbit() {} Rabbit.prototype = { jumps: true }; ``` ``` let rabbit = new Rabbit(); alert(rabbit.constructor === Rabbit); // ``` TRUE / FLASE

Answer 27

FLASE we replace the default prototype as a whole, then there will be no "constructor" in it.

Question 28

The value of F.prototype should be either an _______ or _______: other values won’t work.

Answer 28

object null

Question 29

The only thing F.prototype does: it sets ___________ of new objects when new F() is called.

Answer 29

[[Prototype]]

Question 30

By default all functions have F.prototype =

Answer 30

{ constructor: F },

Question 31

By default all functions have ____________ = { constructor: F },

Answer 31

F.prototype

Question 32

``` function Rabbit() {} Rabbit.prototype = { eats: true }; ``` let rabbit = new Rabbit(); alert( rabbit.eats ); //

Answer 32

true

Question 33

``` function Rabbit() {} Rabbit.prototype = { eats: true }; ``` let rabbit = new Rabbit(); Rabbit.prototype = {}; alert( rabbit.eats ); // ?

Answer 33

true The assignment to Rabbit.prototype sets up [[Prototype]] for new objects, but it does not affect the existing ones.

Question 34

``` function Rabbit() {} Rabbit.prototype = { eats: true }; ``` let rabbit = new Rabbit(); Rabbit.prototype.eats = false; alert( rabbit.eats ); // ?

Answer 34

false Objects are assigned by reference. The object from Rabbit.prototype is not duplicated, it’s still a single object is referenced both by Rabbit.prototype and by the [[Prototype]] of rabbit. So when we change its content through one reference, it is visible through the other one.

Question 35

``` function Rabbit() {} Rabbit.prototype = { eats: true }; ``` let rabbit = new Rabbit(); delete rabbit.eats; alert( rabbit.eats ); // ?

Answer 35

true All delete operations are applied directly to the object. Here delete rabbit.eats tries to remove eats property from rabbit, but it doesn’t have it. So the operation won’t have any effect.

Question 36

``` function Rabbit() {} Rabbit.prototype = { eats: true }; ``` let rabbit = new Rabbit(); delete Rabbit.prototype.eats; alert( rabbit.eats ); // ?

Answer 36

undefined The property eats is deleted from the prototype, it doesn’t exist any more.

Question 37

TRUE / FALSE User.prototype.constructor == User ? ``` function User(name) { this.name = name; } ``` ``` let user = new User('John'); let user2 = new user.constructor('Pete'); ``` alert( user2.name ); // Pete (worked!)

Answer 37

true

Question 38

``` function User(name) { this.name = name; } User.prototype = {}; ``` ``` let user = new User('John'); let user2 = new user.constructor('Pete'); ``` alert( user2.name ); //

Answer 38

undefined overwrites User.prototype

Question 39

Why user2.name is undefined? ******************************************** ``` function User(name) { this.name = name; } User.prototype = {}; // (*) ``` ``` let user = new User('John'); let user2 = new user.constructor('Pete'); ``` alert( user2.name ); // undefined

Answer 39

First, it looks for constructor in user. Nothing. Then it follows the prototype chain. The prototype of user is User.prototype, and it also has nothing. The value of User.prototype is a plain object {}, its prototype is Object.prototype. And there is Object.prototype.constructor == Object. So it is used.