原型与原型链

本文将从全局对象引入，分别介绍Number、Boolean、String、Object四个对象，然后再详述原型的相关知识。

全局对象Window

首先我们还是先不说原型，先了解一下全局对象以及其中的window对象。

全局对象（global object）：通俗的说就是在脚本的任意地方都可以调用的对象，在浏览器中即window对象。

window对象中，如alert()方法可以写成window.alert()，或者省去window，直接写做alert()。window对象分两种：

一种是ECMAScript规定必须得有的，比如parseInt 、 parseFloat，以及Number() 、Boolean() 、String() 、Object()等。
第二种是各个浏览器有的，因为没有写如标准，所以这些方法在各个浏览器的表现形式都有所不同，比如：alert() 、prompt() 、confirm() 、console()等方法以及 document 、history等对象。

简单类型与对象

声明一个数值类型的变量

//声明简单的数据类型
var n1 = 1;
//声明一个对象，可以用n2.toString()将其转换成字符串
var n2 = new Number(1);

如果我们想声明一个数值类型的变量，可以这么写：var n1 = 1;，这种写法声明的是一个简单类型；
或者这么写：var n2 = new Number(1)，
这种写法下，n2 其实是对象，可以通过 n2.valueOf()来获取该对象的值，
可以用n2.toString();方法将其转换成字符串。
这两种写法所声明的变量最大的不同是，他们在内存中的存储方式是不同的，n1直接声明，那么他就是简单的数据类型，存储在stack内存中，而n2则是声明了一个对象，stack内存中存储着该对象的地址，对象的内容存储在heap内存中。
但是日常我们没有用n2的写法，依然可以使用valueOf()方法 和toSting()方法，既然有简单的方法也可以不影响日常操作，为什么还要创建n1这种复杂的写法呢？。

原因是：JS使用妙计：临时转换（用完了就没了），如果你使用n1的写法，调用了了如valueOf方法，那么JS会创建一个临时的对象，然后调用该对象的方法，调用结束后临时对象就会被垃圾回收掉。

var n =1;
n.xxx = 2;
//①n.xxx = 2;会报错吗？
//n.xxx的值是多少？

答案：n.xxx = 2;这句话不会报错,执行这句话时，JS会创建一个临时对象，为临时对象添加属性，执行这句话后，临时对象就会被回收，如果再执行n.xxx，结果是undefined，因为给n添加完属性后临时对象就会被回收，n本质上还是一个数值，没有临时对象，再去重新创建一个新的对象，里面没有这个属性（有个这属性的对象已经被删了）。

Number对象

Number.valueOf(); 获取对象本身的值
Number.toString(); 将数值转化为字符串
var n2 = new Number(1);
n2.toString();  //"1"
n2.valueOf();  //1

String对象

在JavaScript中，每当定义一个函数数据类型(普通函数、类)时候，都会天生自带一个prototype属性，这个属性指向函数的原型对象，并且这个属性是一个对象数据类型的值。

String的常用属性	含义
String.charAt()	获取字符串中某一位的字符
String.charCodeAt()	获取字符串中某一位的字符的Unicode编码
String.trim()	删除字符串中多余的空格
String1.concat(String2)	连接字符串1和字符串2
String.slice(start,end)	切片，截取字符串（包前不包后），从start到end
String.replace('e','o')	将字符串中的e替换成o(只能替换第一次出现的字符)
String.indexOf()	搜索字符串中的内容(只检测到第一次出现的字符)，没搜到返回-1
String.split()	分隔
String.substr(start[, length])	截取,返回一个字符串中从指定位置开始到指定字符数的字符

var s = new String('hello World');

//获取字符串中某一位的字符
s.charAt(1) ; //"e"

//获取字符串中某一位的字符的Unicode编码
s.charCodeAt(0);  //104

//删除字符串中多余的空格,是左右两面的空格
s.trim();  //"hello World"

//连接字符串1和字符串2,字符串1和字符串2是没有被改变的
var s1 = "hello";
var s2 = " world";
s1.concat(s2);  //"hello world"
console.log(s1);  //"hello"
console.log(s2);  //" world"

//切片，截取字符串（包前不包后），从start到end
s.slice(0,2);  //"he"

//将字符串中的e替换成o(只能替换第一次出现的字符)
s.replace('e','o');  //"hollo World"

//搜索字符串中的内容(只检测到第一次出现的字符)，没搜到返回-1
s.indexOf('s')  //-1

//根据字符串中间的空格分隔字符串，变成数组
s.split();  //["hello World"]

//返回一个字符串中从指定位置开始到指定字符数的字符
s.substr(0);  //"hello World"
s.substr(0,5);  //"hello"

Boolean对象

var b1 = false;
var b2 = new Boolean(false);
if(b1) { console.log('b1') } ;
if(b2) { console.log('b2') } ;

///打印结果为 b2

上述代码之中，b1和b2的值都是false，而使用if判断语句，却将b2转化为了true，那是因为b2本身的数据类型是对象，而对象不论是否是空对象，转化成boolean都是true。

Object对象

var obj1 = {};
var obj2 = {};
obj1 === obj2; // false

上面的代码中，同样都是空数组，但是他们的值是不相等的，因为对象在stack内存中存储的只是其内容在heap内存中的地址，而每个对象的内容在heap内存中的地址是不会一样的，所以对象与对象一般都是不相等的。

公有属性 / 原型

上面说了四种对象，而他们都有相同的一些属性，比如valueOf，toString等，难道JS每次声明一个对象都要写一次这些方法嘛？答案是否定的，因为真要这么写的话会非常占用内存，所以实际上JS引擎是这么做的：把所有的对象共有的属性全部放在heap内存的一个地方，当需要使用的时候，引用这个对象即可，这么操作就会减少不必要的内存浪费，而这个公有属性，就是传说中的原型。

• __proto__就是这些公有属性的引用。

• Object.__proto__指向的就是对象的公有属性。

• 而比如Number对象、String对象、Boolean对象，他们还有各自独有的公用属性，他们的__proto__指向的- 就是各自的独有属性，这些独有属性的__proto__指向对象的公有属性。

• 由此可知obj1.toString === obj2.toString这句话是正确的。

QQ图片20190226002851.png

如上面代码，o是Object的一个实例，所以o的proto指针指向构造o的Object的prototype。这样的意义在于o可以使用Object.prototype里面的方法，例如toString(),o在访问toString方法时，首先会在自身寻找，如果没有找到则会在proto也就是Object.prototype上面查找。

则出现了一些等式：

• obj.__proto__ === Object.prototype 即对象的__proto__指向Object对象的prototype

• num.__proto__ === Number.prototype 即数值的__proto__指向Number对象的共有属性

• num.__proto__.__proto__ === Object.prototype 即Number对象的公有属性的__proto__指向Object对象的公有属性。

• 其他如Boolean对象、String对象和Number对象同理。

我们创建的对象的__proto__ 会用来指向原有的String对象，使得我们可以调用String对象的公有属性。

proto 与 prototype

• 于是我们有了以下结论：

__proto__是某对象公用属性的引用，是为了用户使用其共用属性中的方法而存在的 。

prototype 是浏览器写的，本身就存在，是某对象的共同属性的引用，为了不让对象的公用属性因没有被调用而被垃圾回收而存在。

原型链

在JavaScript中是通过prototype对象指向父类对象，直到指向Object对象为止，这样就形成了一个原型指向的链条，专业术语称之为原型链。

QQ图片20190226144401.png

一些烧脑的等式

通过var 对象 = new 函数；推出其他烧脑的等式

var n = new Number(1);
//var 对象 = new 函数；

//对象的__proto__最终指向某对象的共用属性，构造某对象的函数的prototype也指向某对象的共用属性
//__proto__ 是对象的属性，prototype是函数的属性
对象.__proto__ === 函数.prototype

//函数的prototype是对象，这个对象对应的就是最简单的函数Object
函数.prototype.__proto__ === Object.prototype

//由于函数本身即是函数（最优先被视为函数），也是对象，而函数的构造函数是Function
函数.__proto__ === Function.prototype

//Function即是对象，也是函数，但他优先是个函数
Function.__proto__ === Function.prototype

//Function.prototype也是对象，是普通的对象，所以其对应的函数是Object
Funciton.prototype.__proto__=== Object.prototype

根据上面的各种推论，我们发现了其中最神奇的东西，Function，他即是函数，也是对象，所以他有函数的prorotype，也有对象的__proto__，所以出现了下图的情况：

QQ图片20190226144940.png

即Function.prototype 与Funciton.__proto__互相引用。
另外需要注意的一点：
Object.__proto__ === Function.prototype，因为 Function 是Object的构造函数。