说之前要说基本数据类似 string number null undefined object Boolean symbol，然后是内置对象
布尔型可以是一个对象。Boolean
数字型可以是一个对象。number
字符串也可以是一个对象string
日期是一个对象Date
数学和正则表达式也是对象math regexp
数组是一个对象array
甚至函数也可以是对象function

.log(String instanceof Object)
      console.log(Number instanceof Object)
      console.log(Boolean instanceof Object)
      console.log(Date instanceof Object)
      console.log(Math instanceof Object)
      console.log(RegExp instanceof Object)
      console.log(Array instanceof Object)
      console.log(Function instanceof Object)
      console.log(Error instanceof Object)//true
      true
z.html:44 true
z.html:45 true
z.html:46 true
z.html:47 true
z.html:48 true
z.html:49 true
z.html:50 true
console.log(Object instanceof Object)补充一条 挺重要的
自定义对象的时候 
全部都是true

当对象调用属性或者方法先从自身寻找然后原型链寻找 然后object原型链寻找 object可以说是根对象 如果找到了object根对象都没有找到说明undefined

.prototype.r=1
      console.log(String.r)
      console.log(Number.r)
      console.log(Boolean.r)
      console.log(Date.r)
      console.log(Math.r)
      console.log(RegExp.r)
      console.log(Array.r)
      console.log(Function.r)
      console.log(Error.r)
      console.log(Object.r)
      //结果全是1
.prototype.r=1
      const zhen={
        ah:3
      }
      zhen.__proto__.d=4
      const jia={
        ha:2
      }
      jia.__proto__=zhen.__proto__
      jia.__proto__.c=1
      console.log(jia)
      {ha: 2}
ha:2//自身属性
__proto__:
c:1//c是自身原型链
d:4//d是zhen原型链上面的属性
r:1//Object.prototype.r

下图在原型链上赋值了对象zhen

.prototype.r=1
      const zhen={
        ah:3
      }
      zhen.__proto__.d=4
      const jia={
        ha:2
      }
      jia.__proto__=zhen
      jia.__proto__.c=1
      console.log(jia)

{ha: 2}
ha:2
__proto__:这是自身原型链带来的
ah:3//zhen的属性
c:1//jia.__proto__.c
__proto__:
d:4//zhen.__proto__.d 这是zhen的原型链带来的
r:1//Object.prototype.r 这是根对象的原型链 带来了

接下来就是原型指向的问题

const x=new Xiao();//xiao是构造函数 其实也就是函数内置对象的子对象，先继承函数对象 然后是object 根对象原型链
      const y={
        
      }
      const z=new Object()
      三种构建对象的方法  object 根对象原型链是最大的父级
      x,y,z属于实例化的对象别名 __proto__
      new

然后就是基于原型链的继承问题
如果原型属性与本身属性 冲突 自身优先
继承就是子对象 可以重写或者调用父级的方法属性

基于构造函数的继承
call apply

function qw(q,w){
        this.a=1;
        this.q=q;
        this.w=w;
        this.b=function(){
          console.log(q)
        }
      }
      function er(a,b){
        qw.apply(this,[a,b])//需要继承函数初始化使用apply
        //不需要使用call
      }
      const re=new er(1,2);
      console.log(re)

输出如下

er {a: 1, q: 1, w: 2, b: ƒ}
a:1
b:ƒ ()
q:
1
w:2
__proto__:
constructor:ƒ er(a,b)