OOP_RSE_Javascript

Question 1

What kind of JavaScript OOP inheritance applies to the ES6 classes?

Answer 1

Prototypal inheritance

Question 2

ES6 classes&raquo_space;> can they be defined by declaring them or by using an expression?

Answer 2

They can be defined by both:
Declaration: class Bird{...}
Expression:
     a. unnamed class expression: let animal = class { ... };
     b. named class expression: let animal = class Animal{...};

Question 3

How do you access a class’ name ?

Answer 3

If you use a named class expression, the “name” attribute will become a property on the class’s body and can be accessed using “.name”

Question 4

What happens if you declare multiple constructors in an ES6 class?

Answer 4

There is only one constructor in a class, so you will get an “Syntax Error” error

Question 5

How do you use the “super” keyword in an ES6 class?

Answer 5

The super keyword can be used within an object’s constructor to call the constructor of its superclass.

Question 6

What is the difference in defining ES5 vs ES6 prototype methods in a class?

Answer 6

In ES5, you had to use the "prototype" keyword:
     Animal.prototype.bite(...){...}'
In ES6: 
     class {
          ......
          bite( ) { ....}
     }

Question 7

What kind of methods can you declare in an ES6 class?

Answer 7

Prototypal and static

Question 8

What happens if you try to access a static class method from an instance in ES6?

Answer 8

TypeError: “yourStaticMethod” is not a function

Question 9

What happens if you redeclare a class in ES6?

Answer 9

Syntax Error: identifier “myClass” already declared

Question 10

What do you have to do in an ES6 inherited class before you use “this”?

Answer 10

You have to use “super()”;

Question 11

What kind of property is the “prototype” property for a JavaScript object?

Answer 11

It is a private property

Question 12

How do you create privacy in object literals?

Answer 12

By using IIFEs. for ex.:
var myObj = (function( ) { var ... } ( ) );

Question 13

How do you create privacy in object literals?

Answer 13

By using IIFEs. for ex.:
var myObj = (function( ) { var ...; myObj = { } ( ) );

Question 14

How do you declare private vars in a class?

Answer 14

You declare them with “var myVar = …” in the constructor; the ones declared with this.myVar will become public

Question 15

Can you access private class’s vars from the Object’s own public methods? if yes, how, if no, how do you still access them?

Answer 15

No, you cannot access private vars from an object’s public methods. You can access the private vars from the objects’s private methods though.

Question 16

How do you define private methods in JavaScript?

Answer 16

By declaring the corresponding functions inside the constructor

Question 17

How do you make the object available to the private methods inside the object? Why is it that you have to use that way?

Answer 17

By using: “var that = this” inside the constructor. Because Crockford’s pattern, “this” will point to global inside inner private functions in an object.

Question 18

Can you call private methods from public methods in an ES6 class?

Answer 18

No

Question 19

How do you define privileged methods in ES6 and what are they?

Answer 19

use “this.myMethod” inside the constructor to define a privileged method; they are used to access the private methods from the outside of the object

Question 20

Are the privileged methods visible to the public methods inside an ES6 class?

Answer 20

Yes

Question 21

In an object literal: 
var jane = {name: "Jane",
                  describe: function(){console.log(this)},
what is the "this" in the describe function pointing to?

Answer 21

is pointing to the actual object

Question 22

Can you delete an inherited property in an Object?

Answer 22

No

Question 23

Can an ES6 class’s body include data properties?

Answer 23

No, as the class’s body is actually the prototype, so prototypes having data properties are an anti-pattern

Question 24

Can an ES6 class’s body include data properties?

Answer 24

No, as the class’s body is actually the prototype, so prototypes having data properties are an anti-pattern
A class’s body can only contain methods!!!

Question 25

What is the boolean’s value of the following statement and why?
Foo === Foo.prototype.constructor

Answer 25

True, because the Foo.prototype.constructor points back to the Foo function

Question 26

In how many ways can super( ) can be used in a class?

Answer 26

Method definitions (in object literals or classes, with or without static) use it like property references (super.prop) or method calls (super.method(···)), in order to refer to super-properties (line B).

Question 27

Does an inherited class actually inherit the static properties/methods of the parent class?

Answer 27

yes. As an example:
class Foo {
    static classMethod() {
        return 'hello';
    }
}

class Bar extends Foo {
}
Bar.classMethod(); // 'hello'

Question 28

When is it NOT necessary to call super( ) in a class constructor?

Answer 28

When you override the constructor result:
class Foo {
    constructor() {
        return Object.create(null);
    }
}
console.log(new Foo() instanceof Foo); // false

Question 29

What happens if you do not specify a constructor in ES6 classes?

Answer 29

It will use a default constructor:

constructor( ) { }

Question 30

What is the default constructor for the derived classes?

Answer 30

constructor(…args){
super(…args);
}

Question 31

How can you define you own error class in ES6?

Answer 31

class MyError extends Error{ };
throw new MyError.

Question 32

How do you define prototype methods in ES6 classes?

Answer 32

Just define a function inside the class, but outside the constructor:

class C {
    m() {}
}

Question 33

Can you use prototype methods as constructors in ES6?

Answer 33

No;
class C {
    m() {}
}
let a = new C.prototype.m(); // TypeError

Question 34

How are static methods in an ES6 class (in terms of enumerability, writability, configurability)?

Answer 34

Static methods Foo.* are writable and configurable, but not enumerable.

Question 35

How is the prototype of an ES6 class (in terms of enumerability, writability, configurability)?

Answer 35

Foo.prototype is non-writeable, non-enumerable, non-configurable.

Question 36

How is the constructor of an ES6 class (in terms of enumerability, writability, configurability)?

Answer 36

Foo.prototype.constructor is non-writeable, non-enumerable, non-configurable.

Question 37

How are the prototype methods in an ES6 class (in terms of enumerability, writability, configurability)?

Answer 37

Prototype methods Foo.prototype.* are writable and configurable, but not enumerable.

Question 38

What is the prototype of a base class?

Answer 38

Function.prototype

Question 39

When is the instance object created in ES5vs ES6?

Answer 39

The instance object is created in different locations in ES6 and ES5:

In ES6, it is created in the base constructor, the last in a chain of constructor calls.
In ES5, it is created in the operand of new, the first in a chain of constructor calls.

Question 40

Can you call super( ) twice in a derived class constructor?

Answer 40

No.

Once this is initialized, calling super() produces a ReferenceError. This protects you against calling super() twice.

Question 41

What is the return value of a constructor if it doesn’t have a “return” statement?

Answer 41

If a constructor returns implicitly (without a return statement), the result is “this”

Question 42

When do I have to initialize “this” in a constructor that returns an object?

Answer 42

If a constructor explicitly returns an object, it is used as its result. Then it doesn’t matter whether this is initialized or not.

Question 43

Can you subclass built-in constructors in ES5? What about ES6?

Answer 43

Not in ES5, yes in ES6.

Question 44

How do you create a non-deletable object property?

Answer 44

Object.defineProperty(obj, “myProp”) ,{
value: …….
configurable: false
}

Question 45

How do you convert “arguments” in a function to an Array?

Answer 45

var args = Array.prototype.slice.call(arguments);

Question 46

Are objects passed around in JavaScript by reference or by value?

Answer 46

By reference, they are never copied.

Question 47

What is the best way to dereference on object in JavaScript?

Answer 47

myObj = null;

Question 48

What is the prototype of literal objects?

Answer 48

Object.prototype

Question 49

What is “this” pointing to in a prototype chain?

Answer 49

It is always the object where the search began, not the object where the search actually found the method

Question 50

How do you create an object without prototype?

Answer 50

let d = Object.create(null)

Question 51

How do you check if a property actually exists in an object?

Answer 51

({ }.hasOwnProperty.call(obj,prop));

Question 52

How do you change a property in the prototype chain?

Answer 52

You have to first find the object in the prototype chain that actually has the property, and only then to delete it. Something like:
delete getDefiningObject(obj,'myProp');

Question 53

What happens to the objects down the proto chain if I modify a prototype?

Answer 53

The proto chain will reflect the change immediately across the whole chain

Question 54

Object.keys() ==> which of the following cases is actually covering:

1. Enumerable / Non-enumerable;
2. Own / inherited properties.

Answer 54

Own/enumerable

Question 55

Object.getOwnPropertyNames() ==> which of the following cases is actually covering:

1. Enumerable / Non-enumerable;
2. Own / inherited properties.

Answer 55

Own/enumerable and non-enumerable

Question 56

What is “for var … in … “ actually considering? Enumerable/non-enumerable and/or own/inherited properties?

Answer 56

enumerable/ own & inherited

Question 57

How are the properties you create on an object by default - enumerable or non-enumerable? Are they going to appear in (for var … in … )?

Answer 57

They are enumerable, and yes, they will come up in “for var … in … )

Question 58

How do you check if a property actually exists in an object or in the inherited chain?

Answer 58

propkey in obj

Question 59

Are the getters() and setter() actually inherited from the prototype or not?

Answer 59

Yes they are