原型规则

所有的引用类型（数组，函数，对象），都有一个proto属性，属性值是一个对象

_proto叫隐式原型

var a = {}  // 是var a = new Object()的语法糖
function fn(){}
a.name = 'qq'
console.log(a._proto_)

console.log(a.prototype)// 函数的显示原型属性

console.log(a._proto_ === Object.prototype) 
//所有的引用类型（数组，对象，函数），它的_proto_都指向其构造函数的prototype
//什么叫指向：就是===


[Running] node "C:\Users\ADMINI~1\AppData\Local\Temp\tempCodeRunnerFile.javascript"
undefined

所有的函数，都有一个proto属性，属性值是一个对象

prototype叫显式原型

当试图得到某个对象的摸个属性的时候，如果这个对象本身没有这个属性，那么它会去这个对象的_proto_中寻找，也就是这个对象对应的构造函数的prototype中寻找

当试图得到某个对象的摸个属性的时候，如果这个对象本身没有这个属性，那么它会去这个对象的`_proto_`中寻找，也就是这个对象对应的构造函数的prototype中寻找

function Foo(name, age){
this.name = name;
this.age = age;
}

// 通过函数的prototype设置引用类型的属性
Foo.prototype.alertName = function(){
console.log(this.name,this.age)
}

var foo = new Foo('lisi',20)
// 直接设置引用类型的属性
foo.printName = function(){
console.log(this.name,this.age)   // 通过对象的属性来调用函数的时候，无论函数是自己的属性还是构造函数的属性，它的this永远指向对象本身
}

foo.printName()
foo.alertName()
foo.toString()    //这个要去foo._proto_._proto_中找，找不到就不找了

for(var item in foo){
if(foo.hasOwnProperty){
  console.log(item)
}
/* [Running] node "C:\Users\ADMINI~1\AppData\Local\Temp\tempCodeRunnerFile.javascript"
  lisi 20
  lisi 20
  name
  age
  printName 
  结果中没有构造函数prototype中的属性，都是直接是foo对象的属性
*/
      
console.log(item)
//结果中多出了alertName（这是构造函数prototype中的属性）
}


[Running] node "C:\Users\ADMINI~1\AppData\Local\Temp\tempCodeRunnerFile.javascript"
lisi 20
lisi 20

instanceOf

用来判断引用类型（对象，数组等等）属于哪个构造函数

原理：如上面的例子，判断foo是否属于Foo的逻辑原理就是

判断foo的proto，一级一级往上，看是否可以对应到Foo.prototype

注意

引用类型是

扩展：

引用类型和数据类型的区别是

当数据类型的变量赋值给另一个变量的时候，修改其中一个变量的值，不会影响另外一个变量
// 基本数据类型   
var a=10;
var b=a; //b=10
    a=20;
console.log(b); //b还是10
当把引用类型的变量赋值给另外一个引用类型变量时，修改其中一个变量的值，另外一个变量的值会随之改变，看下面的例子：
// 引用类型
var arr1=[1,2,3,4,5];
var arr2=arr1; //arr2=[1,2,3,4,5]
arr2[1]=23;
console.log(arr1); //arr1=[1,1,3,4,5]

var obj1={name:"tom"};
var obj2=obj1; //boj1={name:'tom'}
obj2.name="jack";
console.log(obj1.name) //boj1={name:'jack'}

基本数据类型有这五种:Undefined、Null、String、Number、Boolean。

引用类型有这几种：object、Array、RegExp、Date、Function、特殊的基本包装类型(String、Number、Boolean)以及单体内置对象(Global、Math)。

如何判断一个变量是不是数组类型

用instanceof而不是typeof
var arr = [];
arr instanceof Array  // true
typeof arr  // Object,注意，typeOf是无法判断是否是数组的

class相关问题（class与函数的关系？class的静态方法跟普通方法的对比？）自己提出两个有关的问题并解决

es6中class与函数的关系

es5 中的function 可以用call apply bind 的方式来改变他的执行上下文

但是class 却不可以 class 虽然本质上也是一个函数但是其内（babel）部做了一层代理来禁止了这种行为

https://blog.csdn.net/qq_37653449/article/details/83306769

es5中函数定义类

// es5中函数定义类

function Foo(x,y){
this.x = x;
this.y = y;
}

Foo.prototype.toString = function(){
console.log('(' + this.x + ', ' + this.y + ')')  // +用来连接字符串
}

var f = new Foo(1,2)
f.toString()  



[Running] node "C:\Users\ADMINI~1\AppData\Local\Temp\tempCodeRunnerFile.javascript"
(1, 2)

es6中类的使用方法

// es6中类的使用方法(注意要安装babel依赖，不然es6用不了)
class Foo(x,y) {   
 /* 
   上一行可以换成Foo.prototype(x,y),因为Point === Point.prototype.constructor  //true
 */
constructor(){
 this.x = x;
 this.y = y;
}
toString(){
 console.log('(' + this.x + ',' + this.y + ')')
}
}

var foo = new Foo(1,2)




[Running] node "C:\Users\ADMINI~1\AppData\Local\Temp\tempCodeRunnerFile.javascript"
(1, 2)