//  a  b  f  o 
let f = function () {
  this.a = 1;
  this.b = 2;
};
let o = new f(); // {a: 1, b: 2}

//  f 
f.prototype.b = 3;
f.prototype.c = 4;

//  f.prototype = {b:3,c:4}; 
// o.[[Prototype]]  b  c {b: 3, c: 4}
// o.[[Prototype]].[[Prototype]]  Object.prototype.
//  o.[[Prototype]].[[Prototype]].[[Prototype]]  null
//  null  [[Prototype]]
// 
// {a: 1, b: 2} ---> {b: 3, c: 4} ---> Object.prototype ---> null

console.log(o.a); // 1
// o a 1

console.log(o.b); // 2
// o b 2
// o b
// property shadowing

console.log(o.c); // 4
// o c o 
// o o.[[Prototype]]c 4

console.log(o.d); // undefined
// o d o 
// o o.[[Prototype]]d o.[[Prototype]] 
// o.[[Prototype]].[[Prototype]]  Object.prototyped
// o o.[[Prototype]].[[Prototype]].[[Prototype]] null
//  undefined

var o = {
  a: 2,
  m: function () {
    return this.a + 1;
  },
};

console.log(o.m()); // 3
//  o.m this o

var p = Object.create(o);
// p  o 

p.a = 4; //  p a
console.log(p.m()); // 5
//  p.m this p
//  p  o  m 
// this.a p.a p a

var o = { a: 1 };

//  o  [[Prototype]]  Object.prototype
// o hasOwnProperty
//  hasOwnProperty  Object.prototype 
//  o  Object.prototype  hasOwnProperty
// Object.prototype  null
// o ---> Object.prototype ---> null

var a = ["yo", "whadup", "?"];

//  Array.prototype  indexOfforEach
// 
// a ---> Array.prototype ---> Object.prototype ---> null

function f() {
  return 2;
}

//  Function.prototype  callbind
// f ---> Function.prototype ---> Object.prototype ---> null

function Graph() {
  this.vertices = [];
  this.edges = [];
}

Graph.prototype = {
  addVertex: function (v) {
    this.vertices.push(v);
  },
};

var g = new Graph();
// g verticesedges
//  new Graph()  g.[[Prototype]]  Graph.prototype 

var a = { a: 1 };
// a ---> Object.prototype ---> null

var b = Object.create(a);
// b ---> a ---> Object.prototype ---> null
console.log(b.a); // 1 (inherited)

var c = Object.create(b);
// c ---> b ---> a ---> Object.prototype ---> null

var d = Object.create(null);
// d ---> null
console.log(d.hasOwnProperty);
// undefined, because d doesn't inherit from Object.prototype

"use strict";

class Polygon {
  constructor(height, width) {
    this.height = height;
    this.width = width;
  }
}

class Square extends Polygon {
  constructor(sideLength) {
    super(sideLength, sideLength);
  }
  get area() {
    return this.height * this.width;
  }
  set sideLength(newLength) {
    this.height = newLength;
    this.width = newLength;
  }
}

var square = new Square(2);

console.log(g.hasOwnProperty("vertices"));
// true

console.log(g.hasOwnProperty("nope"));
// false

console.log(g.hasOwnProperty("addVertex"));
// false

console.log(g.__proto__.hasOwnProperty("addVertex"));
// true

function A(a) {
  this.varA = a;
}

//  A.prototype.varA  this.varA shadowed
//  varA 
A.prototype = {
  varA: null, //  varA 
  // 
  // https://developers.google.com/speed/articles/optimizing-javascript#Initializing instance variables
  //  varA 
  doSomething: function () {
    // ...
  },
};

function B(a, b) {
  A.call(this, a);
  this.varB = b;
}
B.prototype = Object.create(A.prototype, {
  varB: {
    value: null,
    enumerable: true,
    configurable: true,
    writable: true,
  },
  doSomething: {
    value: function () {
      // override
      A.prototype.doSomething.apply(this, arguments); // call super
      // ...
    },
    enumerable: true,
    configurable: true,
    writable: true,
  },
});
B.prototype.constructor = B;

var b = new B();
b.doSomething();

var o = new Foo();

var o = new Object();
o.[[Prototype]] = Foo.prototype;
Foo.call(o);

o.someProp;