Object Oriented Programming

Question 1

Why OOP?

Answer 1

Clear + Understanable
Easy to extend
Easy to maintain
Memory Efficient
DRY

Question 2

What Closures and Prototypes influenced from something?

Answer 2

Closures are similar to FP(Functional Programming)
Prototypes are similar to OOP(Object Oriented Programming)

Question 3

What are the object property variables called In OOP called?

Answer 3

States

Question 4

What are functions called in OOP?

Answer 4

Methods

Question 5

What are factory functions?

Answer 5

We can use factory functions as a first step towards OOP.
The main drawback is using them for methods as the methods are stored in memory too

Question 6

What is a store?

Answer 6

Store in OOP is where we store the values in Object.

Question 7

What is the stores?

Answer 7

Which only has stores and methods/manipulations are defined outside.

Example of a store.

Question 8

Example of inheritance without class

Answer 8

Question 9

Inheritance without using Object.create?

Answer 9

We can use the constructor function. with the new keywords and this keyword.
Needs title casing.

Question 10

What is a Constructor Function?

Answer 10

Before classes in ES6 we used to using function constructor for write classes.

function Elf(name, type, weapon) {
// not returning anything
// “constructing” a new elf
this.name = name;
this.type = type;
this.weapon = weapon;
}

const dobby = new Elf(“Dobby”, “house”, “cloth”);

Question 11

Why do we need new in constructor function?

Answer 11

The new operator lets developers create an instance of a user-defined object type or of one of the built-in object types that have a constructor function.

Because of lexical scoping, otherwise, this element won’t be added to the variable assigned.

Question 12

What are the constructors in class in ES6?

Answer 12

Classes are syntactic sugar for prototypal inheritance.
Constructors are precisely similar to construct functions.
Yet, they favour ES6 to bring them much closer to OOP.

The constructor method is a class method for creating and initializing an object instance of that class.
In javascript, we also bind the methods which are in array functions.

Constructor runs for each new object or instance created.

Question 13

What are the difference between methods and functions?

Answer 13

Methods are defined inside a class.

Question 14

Difference between Object.create() vs class?

Answer 14

Many call Object.create() is a pure prototypal inheritance.
Newer Es6 codebase people use class for OOP characteristics.

Question 15

this - 4 ways?

Answer 15

1. new binding
2. implicit binding
3. explicit binding
4. arrow functions

// new binding
function Person(name, age) {
this.name = name;
this.age =age;
console.log(this);
}

const person1 = new Person(‘Xavier’, 55)

//implicit binding
const person = {
name: ‘Karen’,
age: 40,
hi() {
console.log(‘hi’ + this.name)
}
}

person.hi()

//explicit binding
const person3 = {
name: ‘Karen’,
age: 40,
hi: function() {
console.log(‘hi’ + this.setTimeout)
}.bind(window)
}

person3.hi()

// arrow functions
const person4 = {
name: ‘Karen’,
age: 40,
hi: function() {
var inner = () => {
console.log(‘hi ‘ + this.name)
}
return inner()
}
}

person4.hi()

Question 16

How can we inherit using class in ES6?

Answer 16

using “extends” keyword

Question 17

How to know if the object belongs to a class?

Answer 17

By using instanceOf keyword

Question 18

So if we extends what happens?

Answer 18

In javascript, it’s basically copy one object and using that object with prototypal inheritance

Question 19

Can we create Private class fields and methods?

Answer 19

In typescript, private visibility is a design-time construct.
# is a representation of private ES2022.

ES2022: Private Class Fields + Methods

class Employee {
#name = “Test”;
constructor(name) {
this.#setName(name) // ok
}
#setName(name) { // Private method
this.#name = name;
}
}

const emp = new Employee(‘New’); // ok
emp.#setName(‘New’); // error

Question 20

4 Pillars of OOP?

Answer 20

Encapsulation
Abstraction
Inheritance
Polymorphism