原型和原型链

参考网站

一、万物皆对象?

  • 什么是对象？

对象是 javascript 基本数据类型。对象是一种复合值： 它将很多值（原始值或者其它对象）聚合在一起，可通过名字访问这些值。

JavaScript 中，对象是拥有属性和方法的数据

JavaScript 对象是动态的可以新增属性和删除属性。

1.1 数据类型

基本类型（原始类型）：Undefined,Null,Boolean,Number,String

引用类型（对象类型）：Object,Array,Date,RegExp,Function,特殊的基本包装类型(String、Number、Boolean)以及单体内置对象(Global、Math)

1.2 基本类型与引用类型区别

  1. 基本类型值不可变，引用类型值可变
  2. // example1.js
  4. var str = 'You can you up'
  5. str.toLowwer()
  6. console.log(str)
  2. // example2.js
  3. var str = 'You can you up'
  4. str.name = 'LW'
  5. str.toString = function(){}
  7. console.log(str.name)
  8. console.log(str.toString)
  2. // example3.js
  3. var person = {};
  4. person.name = 'jeff';
  5. person.age = 18;
  6. person.sayName = function(){console.log(person.name);}
  7. person.sayName();
  9. delete person.name;
  10. person.sayName();
  1. 基本类型的比较是值的比较, 引用类型的比较是引用的比较
  2. var a = 1;
  3. var b = true;
  4. console.log(a == b)
  6. var a = 'jozo';
  7. var b = 'jozo';
  8. console.log(a === b)
  2. # example4.js
  3. var person1 = {};
  4. var person2 = {};
  5. console.log(person1 == person2)
  1. 复制变量时

原始值：在将一个保存着原始值的变量复制给另一个变量时，会将原始值的副本赋值给新变量，此后这两个变量是完全独立的，他们只是拥有相同的 value 而已。

引用值：在将一个保存着对象内存地址的变量复制给另一个变量时，会把这个内存地址赋值给新变量，
也就是说这两个变量都指向了堆内存中的同一个对象，他们中任何一个作出的改变都会反映在另一个身上。

  2. # example5.js
  4. var a = 1
  5. var b = a
  6. b=2
  7. console.log(a)
  9. var obj1 = {name:'jeff',age:18}
  10. var obj2= obj1
  11. obj2.age=20
  12. console.log(`obj1=${obj1}`)
  1. 参数传递的不同

原始值：只是把变量里的值传递给参数，之后参数和这个变量互不影响。

引用值：对象变量它里面的值是这个对象在堆内存中的内存地址

  2. # example6.js
  3. var a=1
  4. var b = {name:'jeff'}
  6. function set(obj){
  7.     obj.age = 20
  8. }
  9. set(a)
  10. set(b)
  11. console.log(a)
  12. console.log(b)

1.3 原始值是对象吗?

  2. var a= `
  3.   产品：'这个需求什么时候做完？'
  4.   程序猿：'下班前做完'
  5.   第二天...
  6.   产品：'你昨天说下班需求做完，到现在你也没做完啊！',
  7.   程序猿：'我还没下班了。'
  8. `
  9. console.log(a.length) // 89

在这里 a 只是一个字符串，不应该存在属性和方法，但事实上他有自己的属性和方法，为什么？

1.4 包装对象

其实在上面的例子中在读取字符串的时候会创建一个对象，但是这个对象只是临时的，所以我们称它为临时对象，学术名字叫包装对象。说它临时，是因为我们在读取它的属性的时候，js 会把这个 string 字符串通过 new String()方式创建一个字符串对象，有了对象自然就有了属性，但是这个对象只是临时的，一旦引用结束，这个对象就被销毁了。

  3. var str = "You can you up"
  4. console.log(str.length)
  6. // 类似于下面的代码
  7. console.log(new String(str).length)

同理数字、布尔值在读取属性的时候也可以通过自己的构造函数来创建自己的一个临时对象

思考

  3. typeof null
  5. typeof undefined

1.5 1 总结

JavaScript 除 undefined 外 几乎所有事物都是对象或看成对象(number,string,boolean)

二、构造函数

Javascript 中的函数即可以当普通函数调用，也可以是构造函数，普通函数通过 new 调用时， 它就是一个构造函数，即构造函数就是一个普通函数。

2.1 构造函数与普通函数的区别

  1. 在命名规则上，构造函数一般是首字母大写，普通函数一般是驼峰命名法；
  2. 调用时，普通函数是直接调用，构造函数通过 new 关键字来生成新的实例(对象)(函数对象);
  3. 构造函数使用 this 定义成员变量和成员方法，普通函数中不使用 this 关键字定义成员变量和方法。
  4. 返回值，普通函数可以有 return, 构造函数一般没有返回值;
  5. 构造函数没返回值时，返回实例对象，有返回值时，校验返回值类型，当为非引用类型时，返回的还是实例对象，当为引用类型时，返回该引用类型 
  2. // example7.js
  4. function Person(name, age) {
  5.   this.name = name
  6.   this.age = age
  7.   this.sayName = function(){
  8.     console.log(this.name,`..`)
  9.   }
  10. }
  12. let person1 = new Person('lw', 30)
  13. person1.sayName()
  2. // example8.js
  4. function Person(name, age) {
  5.   this.name = name
  6.   this.age = age
  7.   this.sayName = function () {
  8.     console.log(this.name)
  9.   }
  10.   return 'hello'
  11.   return {
  12.     a: '1',
  13.     b: '2'
  14.   }
  15. }
  17. let person1 = new Person('lw', 30)
  18. console.log(person1)

2.2 new 关键字

new 执行过程

  1.   let person = new Person('lw',30)
  3.   //伪代码
  4.   var obj = {}
  5.   obj.__proto__ = Person.prototype
  6.   Person.call(obj)
  7.   return obj
  1. 创建空对象
  2. 将空对象的 proto 指向构造函数的 prototype 对象(在此建立 原型链 obj->Person.prototype->Object.prototype->null)
  3. 改变作用域，即将 Person 函数 this 指向新对象 obj,使 obj 继承 Person 的属性和方法，并调用 Person 函数(obj.Person(‘lw’,30))
  4. 判断返回值，返回新对象

2.3 内置构造函数(构造器)

Javascript 内置构造函数有很多，主要是基本类型、引用类型(复合类型)

Object

  2. var obj = new Object()

Function

  2. var sum = Function("a","b","console.log(a+b)")
  3. sum(1,2)

Array

  2. var arr = new Array()

RegExp

  2. var reg = new RegExp("\\d","g")

Number、 String、 Boolen

  2. var num = new Number(20)
  3. var str = new String("test")
  4. var bool = new Boolean(false)

2.4 普通对象与函数对象

凡是通过 new Function()创建的对象都是函数对象，其它的都是普通对象。

  2. // example9.js
  4. var o1 = {};
  5. var o2 = new Object();
  6. var o3 = new f1();
  8. function f1() {};
  9. var f2 = function () {};
  10. var f3 = new Function('str', 'console.log(str)');
  12. console.log(typeof Object);
  13. console.log(typeof Function);
  15. console.log(typeof f1);
  16. console.log(typeof f2);
  17. console.log(typeof f3);
  19. console.log(typeof o1);
  20. console.log(typeof o2);
  21. console.log(typeof o3);

上例中，f1,f2,f3 都是函数对象，o1,o2,03 都是普通对象, Object,Function 也是函数对象.

函数对象可以创建普通对象，普通对象无法创建函数对象。

  2. function foo(){}
  3. typeof foo
  5. var f1 = new foo()
  6. typeof f1

三、原型和原型链

3.1 instanceof

instanceof 运算符用来判断一个构造函数的 prototype 属性所指向的对象是否存在另外一个要检测对象的原型链上

  2.   var obj = {}
  3.   obj instanceof Object // 检测Object.prototype是否存在于参数obj的原型链上。
  2. // example10.js
  4. Function instanceof Object
  5. Function instanceof Function
  7. Object instanceof Function
  8. Object instanceof Object
  10. Function.prototype
  11. Object.prototype

Object 继承自己， Function 继承自己，Object 和 Function 互相继承对方。

原型和原型链的深入浅出 - 图1

  2. // example11.js
  4. function Person() {}
  6. var person1 = new Person()
  8. console.log(person1 instanceof Person)
  9. console.log(person1 instanceof Object)

原型和原型链的深入浅出 - 图2

3.2 constructor 属性

  2. console.log(person1.constructor == Person)

每个实例对象都有 constructor 属性，且 constructor 属性指向构造函数本身。

3.3 原型对象（显示原型）

3.3.1 什么是原型对象?

在 JavaScript 中，每当定义一个对象（函数也是对象）时候，对象中都会包含一些预定义的属性。其中每个函数对象都有一个 prototype 属性，这个属性是一个指针，他指向一个对象，这个对象就是原形对象。

每个函数对象都有 prototype 属性

原型对象，就是一个普通对象。原型对象就是 Person.prototype。

  2. function Person() {
  3.   this.name = 'lw'
  4.   this.age = 30
  5.   this.sayName = function () {
  6.     console.log(this.name)
  7.   }
  8. }
  10. // 改写
  11. function Person(){
  13. }
  15. Person.prototype.name = 'lw'
  16. Person.prototype.age = 30
  17. Person.prototype.sayName = function(){
  18.   console.log(this.name)
  19. }
  21. // 再次改写
  22. Person.prototype = {
  23.   name: 'lw',
  24.   age: 30,
  25.   sayName: function () {
  26.     console.log(this.name)
  27.   }
  28. }

在 默认情况下，所有的原型对象都会自动获得一个 constructorn 属性，这个属性是一个指针，指向 prototype 所在的构造函数

  2. Person.prototype.constructor == Person

前面提到过

  2. person1.constructor =Person

person1 有 constructor 属性，是因为 person1 是 Person 的实例。

那 Person.prototype 为什么有 constructor 属性？同理， Person.prototype （你把它想象成 A） 也是 Person 的实例。
也就是在 Person 创建的时候，创建了一个它的实例对象并赋值给它的 prototype，基本过程如下：

  2. var A = new Person();
  3. Person.prototype = A;

原型对象(Person.prototype)是构造函数(Person)的一个实例

但 Function.prototype 除外，它是函数对象，但它很特殊，他没有 prototype 属性（前面说道函数对象都有 prototype 属性）

  1. function Person(){};
  2.  console.log(Person.prototype)
  3.  console.log(typeof Person.prototype)
  4.  console.log(typeof Function.prototype)
  5.  console.log(typeof Object.prototype)
  6.  console.log(typeof Function.prototype.prototype)

Function.prototype 为什么是函数对象呢？

  2. var A = new Function ();
  3. Function.prototype = A;

上文提到凡是通过 new Function( ) 产生的对象都是函数对象。因为 A 是函数对象，所以 Function.prototype 是函数对象。

3.3.2 原型对象是用来做什么的呢？

主要用于继承

当读取实例的属性时，如果找不到，就会查找与对象关联的原型中的属性，如果还查不到，就去找原型的原型，一直找到最顶层为止。

  2. // example12.js
  4. function Person() {}
  5. Person.prototype.name = 'lw';
  6. var person = new Person();
  7. person.name = 'zk';
  8. console.log(person.name)
  9. delete person.name;
  10. console.log(person.name)
  12. console.log(person.toString())
  13. console.log(Object.prototype)

可以让所有的实例对象共享它所包含的属性和方法，减少内存占用

  2. // example13.js
  4. function A() {
  5.   this.name = 'lw'
  6.   this.sayName = function () {
  7.     return this.name
  8.   }
  9. }
  11. function B() {
  12.   this.name = 'zk'
  13. }
  15. B.prototype.sayName = function () {
  16.   return this.name
  17. }
  19. var a1 = new A()
  20. var a2 = new A()
  21. var b2 = new B()
  22. var b2 = new B()
  24. console.log(a1)
  25. console.log(a2)
  26. console.log(b1)
  27. console.log(b2)

我们通过使用构造函数 A 创建了两个对象,分别是 a1 , a2 ;通过构造函数 B 创建了两个对象 b1 , b2 ;我们可以发现 b1 , b2 这两个对象的那个 sayHello 方法都是指向了它们的构造函数的 prototype 属性的 sayHello 方法.而 a1 , a2 都是在自己内部定义了这个方法.

定义在构造函数内部的方法,会在它的每一个实例上都克隆这个方法;定义在构造函数的 prototype 属性上的方法会让它的所有示例都共享这个方法,但是不会在每个实例的内部重新定义这个方法 .如果我们的应用需要创建很多新的对象,并且这些对象还有许多的方法,为了节省内存,我们建议把这些方法都定义在构造函数的 prototype 属性上 当然,在某些情况下,我们需要将某些方法定义在构造函数中,这种情况一般是因为我们需要访问构造函数内部的私有变量

总结

每个构造函数都有一个原型对象，原型对象都包含一个指针，指向构造函数，而实例对象都包含一个指向原型对象的内部指针。

  2. function Person(){}
  4. Person.prototype.toString = function (){}
  6. var person1 = new Person()
  8. Person.prototype.constructor = Person
  10. person1.constructor = Person

3.4 proto(隐式原型)

JS 在创建对象（不论是普通对象还是函数对象）的时候，都有一个叫做proto的内置属性(隐式原形)，它指向构造该对象的构造函数原型。

对象 person1 有一个 proto属性，创建它的构造函数是 Person，构造函数的原型对象是 Person.prototype ，所以：
person1.proto == Person.prototype

原型和原型链的深入浅出 - 图3

3.5 函数对象

所有函数对象的 proto 都指向 Function.prototype,它是一个空函数

  2. // example14.js
  4. function Person() {}
  5. console.log(Person.__proto__ === Function.prototype) //true
  7. console.log(Number.__proto__ === Function.prototype) // true
  9. console.log(String.__proto__ === Function.prototype) // true
  11. // 所有的构造器都来自于Function.prototype，甚至包括根构造器Object及Function自身
  12. Object.__proto__ === Function.prototype // true
  13. Object.constructor == Function // true
  15. Function.__proto__ === Function.prototype // true
  16. Function.constructor == Function //true

所有的构造器都来自于 Function.prototype，甚至包括根构造器 Object 及 Function 自身。所有构造器都继承了·Function.prototype·的属性及方法。如 length、call、apply、bind

  2. Function.prototype.__proto__ === Object.prototype

所有的构造器也都是一个普通 JS 对象，可以给构造器添加/删除属性等。同时它也继承了 Object.prototype 上的所有方法：toString、valueOf、hasOwnProperty 等

  2. Object.prototype.__proto__ === null

3.6 继承


当我们创建一个函数时：

  2. var Person = new Object()
  3. console.log(Person.prototype)


Person 是 Object 的实例，所以 Person 继承了 Object 的原型对象 Object.prototype 上所有的方法。

当我们定义一个数组时：

  2. var arr = new Array()
  3. console.log(Arr.prototype)


继承了 Array 的原型对象 Array.prototype 上所有的方法.

此处输出是空数组，可以使用 Object.getOwnPropertyNames 获取所有（包括不可枚举的属性）的属性名不包括 prototy 中的属性，返回一个数组：

  1. var arrayAllKeys = Array.prototype; // [] 空数组
  2. // 只得到 arrayAllKeys 这个对象里所有的属性名(不会去找 arrayAllKeys.prototype 中的属性)
  3. console.log(Object.getOwnPropertyNames(arrayAllKeys));
  4. /* 输出：
  5. ["length", "constructor", "toString", "toLocaleString", "join", "pop", "push",
  6. "concat", "reverse", "shift", "unshift", "slice", "splice", "sort", "filter", "forEach",
  7. "some", "every", "map", "indexOf", "lastIndexOf", "reduce", "reduceRight",
  8. "entries", "keys", "copyWithin", "find", "findIndex", "fill"]
  9. */


细心的你肯定发现了 Object.getOwnPropertyNames(arrayAllKeys) 输出的数组里并没有 constructor/hasOwnPrototype 等对象的方法（你肯定没发现）。
但是随便定义的数组也能用这些方法

  2. var num = [1];
  3. console.log(num.hasOwnPrototype())


因为 Array.prototype 虽然没这些方法，但是它有原型对象（proto）

  2. Array.prototype.__proto__ == Object.prototype


所以 Array.prototype 继承了对象的所有方法，当你用 num.hasOwnPrototype()时，JS 会先查一下它的构造函数 （Array） 的原型对象 Array.prototype 有没有有 hasOwnPrototype()方法，没查到的话继续查一下 Array.prototype 的原型对象 Array.prototype.proto有没有这个方法

3.7 原型链 

  2. function Person(){}
  3. var person1 = new Person();
  4. console.log(person1.**proto** === Person.prototype); // true
  5. console.log(Person.prototype.**proto** === Object.prototype) //true
  6. console.log(Object.prototype.**proto**) //null
  8. Person.**proto** == Function.prototype; //true
  9. console.log(Function.prototype)// function(){} (空函数)
  11. var num = new Array()
  12. console.log(num.**proto** == Array.prototype) // true
  13. console.log( Array.prototype.**proto** == Object.prototype) // true
  14. console.log(Array.prototype) // [](空数组)
  15. console.log(Object.prototype.**proto**) //null
  17. console.log(Array.**proto** == Function.prototype)// true


原型和原型链的深入浅出 - 图4

3.7 总结


原型和原型链是 js 实现继承的一种模式

原型链的形成是靠proto,而非 prototype