1.toString()
它的作用是:将某一个值转化为字符串
我们先看个demo：
var t1 = {a: 1};
var t2 = [1,2];
var t3 = 'str';
var t4= 5
var t5=true
console.log(t1.toString()) //"[object Object]"
console.log(t2.toString()) //"1,2"
console.log(t3.toString()) // "str"
console.log(t4.toString()) // "4"
console.log(t5.toString()) // "true"
在上面的例子中，我们定义了对象、数组、字符串三个类型来调用toString方法，但是结果却完全不一样。奇怪？
从例子上看，
- 对象返回的是貌似可以反映出其类型的字符串
- 数组返回的是字符串列表
- 字符串返回的是字符串副本（即原样输出）
所以从结果看，貌似不同类型的toString的方法功能不一样（虽然名字都叫toString）。
- t1调用的是Object.prototype里的方法
- t2调用的是Array.prototype里的方法
- t3调用的是String.prototype里的方法
虽然t2也是对象，但其原型链上的第一层Array.prototype就有toString方法，所以就会直接继承，而不会再去找Array.prototype.__proto__即Object.prototype中的toString方法，所以不同类型的原型链式或多或少都 重写了toString方法，所以功能用处都不一样。
接下来，我们再来分析一下不同类型调用toString()方法，返回值有什么不同之处？
1.1.字符串string（即调用 new String出来的基本包装类型的方法）
返回字符串的一个副本（即原样输出）
var str = "a";
str.toString(); //"a"
String.prototype.toString.call(str) // "a"
1.2.数值number（即调用 new Number出来的基本包装类型的方法）
返回字符串形式的数值
var num = 520;
num.toString(); //"520"
Number.prototype.toString.call(num) // "a"
1.3.布尔值boolean（即调用 new Boolean出来的基本包装类型的方法）
返回字符串"true"或"false"
var boo = true;
boo.toString(); //"true"
Boolean.prototype.toString.call(boo); //"true"
1.4.独一无二值symbol(即调用构造函数Symbol生成的实例方法，注这里调用和一般的构造函数不一样，不需要new，直接调用)
返回字符串"Symbol()"
var symbol = Symbol();
symbol.toString(); //"Symbol()"
Symbol.prototype.toString.call(symbol); //"Symbol()"
1.5.null和undefined
null和undefined没有相应的构造函数，所以它们没有也无法调用toString()方法，也就是说它们不能访问任何属性和方法，只是基本类型而已。
16.对象object（即调用Object.prototype的方法）
返回
[object type]，其中type为对象的类型
var t1 = {a: 1};
t1.toString() //"[object Object]"
Object.prototype.toString.call(t1); //"[object Object]"
1.7.数组Array（即调用Array.prototype的方法）
返回由数组中每个值的字符串形式 拼接而成的一个以逗号分隔的字符串
var array = [1, 's', true, {a: 2}];
array.toString();//"1,s,true,[object Object]"
Array.prototype.toString.call(array);//"1,s,true,[object Object]"
1.8.函数function（即调用Function.prototype的方法）
返回函数的代码
function foo(){
console.log(1');
};
foo.toString();
<!--"function foo(){-->
<!-- console.log(1);-->
<!--}"-->
Function.prototype.toString.call(foo);
<!--"function foo(){-->
<!-- console.log(1');-->
<!--}"-->
所以：
Object.toString();
//"function Object() { [native code] }"
Function.toString();
//"function Function() { [native code] }"
Array.toString();
//"function Array() { [native code] }"
....
因为
Array.__proto__===Function.prototype //true
Object.__proto__===Function.prototype //true
Function.__proto__===Function.prototype //true
1.9.日期Date（即调用Date.prototype的方法）
返回带有时区信息的日期和时间
var date = new Date();
date.toString();
//"Fri May 11 2018 14:55:43 GMT+0800 (中国标准时间)"
Date.prototype.toString.call(date);
//"Fri May 11 2018 14:55:43 GMT+0800 (中国标准时间)"
1.10.正则表达式RegExp（即调用RegExp.prototype的方法）
返回正则表达式的字符串形式
var re = /cat/g;
re.toString();// "/cat/g"
RegExp.prototype.toString.call(re);// "/cat/g"
1.11.全局对象window
返回
[object window]
window.toString(); //"[object Window]"
Object.prototype.toString.call(window); //"[object Window]"
window是js中的特殊对象，Window并不是个构造函数，也就是说并没有Window.prototype原型对象上重写toString()方法，它会顺着原型链查找调用Object.prototype.toString()。
2.Object.prototype.toString.call( )
上面我们通过直接调用和call调用两种方式进行toString方法测试。我们知道对应object返回的结果是[object type]，其中type为对象的类型`，那么我们可以根据其返回对象的功能进行类型判断。
Object.prototype.toString.call({});
<!--"[object Object]"-->
Object.prototype.toString.call([]);
<!--"[object Array]"-->
Object.prototype.toString.call(function(){});
<!--"[object Function]"-->
Object.prototype.toString.call('');
<!--"[object String]"-->
Object.prototype.toString.call(1);
<!--"[object Number]"-->
Object.prototype.toString.call(true);
<!--"[object Boolean]"-->
Object.prototype.toString.call(null);
<!--"[object Null]"-->
Object.prototype.toString.call(undefined);
<!--"[object Undefined]"-->
Object.prototype.toString.call();
<!--"[object Undefined]"-->
Object.prototype.toString.call(new Date());
<!--"[object Date]"-->
Object.prototype.toString.call(/at/);
<!--"[object RegExp]"-->
3.直接调用
toString();
<!--"[object Undefined]"-->
(function(){
console.log(toString());
})();
<!--[object Undefined]-->
也就是说直接调用toString()方法，等价于
Object.prototype.toString.call();
<!--"[object Undefined]"-->
Object.prototype.toString.call(undefined);
<!--"[object Undefined]"-->
即：直接调用toString()方法这里不可以理解成为全局作用域调用toString()方法，即window.toString()
所以直接调用toString()应该就是变相的undefined.toString()方法（这里说的是相当于，实际undefined并没有方法，调用会报错）。
4.toString.call/apply(类型)
经常有人用toString.call/apply(类型)去代替Object.prototype.toString.call/apply(类型)使用，其实这样是不严谨的，容易导致一些问题，如下所示
function toString(){
console.log(1")
}
toString();//1
toString.call({});//1
toString.call([]);//1
我们可以发现，当我们自定义了toString()方法时，直接调用toString()方法，就不会再默认调用Object类的toString()方法，而是会使用我们自定义的方法，这样可能得不到我们想要的结果，所以我们还是应当尽量使用Object.prototype.toString.call/apply(类型)。
5.类型
类似toString()方法，Object的不同子类型还重写了toLocaleString()、valueOf()等方法，这里我想说的是不管对象子类型怎么重写方法，只要我们明白这些方法是哪里来的，怎么调用的，就能很好的理解这些方法调用后产生的结果！
说到底，对JS中对象和原型的理解真的非常非常重要！
