Please enable JavaScript.

Coggle requires JavaScript to display documents.

object oriented Javascript - Coggle Diagram

- - - - log → Person
      - can be used to access any properties and methods within Person
    - - log → Window
  - - - this.name = name;
    - - this.calculateAge = function () { ... };
- - - - const arr1 = [1,2,3,4];
      - const arr2 = new Array(1,2,3,4);
- - - - Person.prototype
  - - - given a pseudo property __proto__
        
        it represents: Person.prototype
        
        anything we put into the Person prototype will show up here (__proto__)
        
        has itself a __proto__ property which represents Object.prototype → the top of the chain
    - - → calculate age is going to be the same for every person (no different in the function)
        
        this function should be put in prototype, not directly into the object
        
        Person.prototype.calculateAge = function(){ ... }
        
        now available on the __proto__ property
        
        can be used as before → john.calculateAge())
      - no need to flood the constructor with similar methods
        
        Person.prototype.getFullName = function(){ ... }
        
        can also manipulate data
        
        Person.prototype.getsMaried = function(newLastName){ ... }
- - - - function Person(firstName, lastName) { ... }
      - Person.prototype.greeting = function(){ ... }
      - const person1 = new Person('John', 'Doe');
    - - function Customer(firstName, lastName, phone, membership) { ... }
        
        Person.call(this, firstName, lastName);
        
        call is a function that allows us to call another function in the current context
        
        doesn't inherit the prototype → want to inherit the Person prototype methods
        
        Customer.prototype = Object.create(Person.prototype);
        
        Customer.prototype.constructor = Customer;
      - can overwrite Person prototypes with new prototypes
        
        e.g. another greeting
        
        Customer.prototype.greeting = function(){ ... }
- - - - can add properties
        
        alternate method
        
        const brad = Object.create(personPrototypes, { ... }
        
        firstName: {value: 'Brad'},
      - mary.firstName = 'Mary';
      - mary.getsMarried('Thompson');
- - - - this.firstName = firstName
    - - greeting() { ... }
      - calculateAge() { ... }
      - static methods → methods you can use without instantiating an object ;-)
        
        static addNumbers(x, y) { ... }
        
        Person.addNumbers(1,2)
        
        functions that do not require specific object properties → a stand alone method
- - - - this.firstName = firstName
    - - constructor(firstName, lastName, phone, membership) { ... }
      - static getMembershipCost() { ... }
      - super(firstName, lastName);
      - this.phone = phone; this.membership = membership;