JavaScript 对象的toString()和valueOf()

在进行数据转化时，所有对象继承了两个转换方法：
toString()：返回一个反映这个对象的字符串；
valueOf()：返回它相应的原始值。

1、toString()

当对象表示为文本值时或期望以字符串的方式引用对象时，该方法被自动调用。对象obj在调用toString() 返回形如：[object type]。其中type是对象类型。如果obj不是对象，toString() 返回obj应有的文本值(不是单纯的加”“)。

        let obj ={};
        console.log(obj.toString());//[object Object]
        console.log(obj.toString.call(new String));//[object String]
        console.log(obj.toString.call(new Date));//[object Date]
        console.log(obj.toString.call(new Array));//[object Array]
        console.log(obj.toString.call(new Number));//[object Number]
        console.log(obj.toString.call(Function));//[object Function]
        console.log(obj.toString.call(Math));//[object Math]
        console.log(obj.toString.call(undefined));//[object Undefined]
        console.log(obj.toString.call(null));//[object Null]
-----------------------------------------------------------------------------
        let objArr = [1, 2, 3, 4, 5];
        console.log(objArr.toString());//1,2,3,4,5
        let arr =[{id:123,name:'ShangSan'},'2',3,true];
        console.log(arr.toString());//[object Object],2,3,,true
        let objNum = 12345;
        console.log(objNum.toString());//12345
        let objBoolean=true;
        console.log(objBoolean.toString());//true
        let objFunc = function () {
            console.log('param');
        }
        console.log(objFunc.toString());
        // function () {
        //     console.log('param');
        // }

也可以复写这个方法(自定义这个方法，这个方法没有参数且必须有个返回值)。

        let obj = {
            toString:function(){
                return '我是toString方法';
            }
        };
       console.log(obj.toString());//我是toString方法
       console.log(obj.toString.call(new String));//我是toString方法

不同类型对象的toString()方法的返回值

2、valueOf()

JavaScript 调用 valueOf() 方法用来把对象转换成原始类型的值（数值、字符串和布尔值） 。默认情况下, valueOf() 会被每个对象Object继承。每一个内置对象都会覆盖这个方法为了返回一个合理的值，如果对象没有原始值，valueOf() 就会返回对象自身。

不同类型对象的valueOf()方法的返回值

 //let objArr = [1, 2, 3, 4, 5];
        let objArr = ['a', 'b', 'c', 'd', 'f'];
        console.log(objArr.valueOf());//["a", "b", "c", "d", "f"]
        let objBoolean = true;
        console.log(objBoolean.valueOf());//true
        let objDate = new Date();
        console.log(objDate.valueOf());//1555381853497
        let objFunc = function () {
            console.log('param');
        }
        console.log(objFunc.valueOf());
        // ƒ () {
        //     console.log('param');
        // }
        let objNum = 12345;
        console.log(objNum.valueOf());//12345
        let obj = {
            id: '1001',
            age: 19
        };
        console.log(obj.valueOf());//{id: "1001", age: 19}
        let objStr = new String('abcdfe');
        console.log(objStr.valueOf());//abcdfe

也可以复写这个方法(自定义这个方法，这个方法没有参数且必须有个返回值)。

        let obj = {
            valueOf:function(){
                return '我是valueOf方法';
            }
        };
        console.log(obj.valueOf());//我是valueOf方法
        console.log(obj.valueOf.call(new String));//我是valueOf方法

那么问题来了，对象何时调用 toString(),何时调用 valueOf()？？？

3、优先级

我们下面通过实例还说明，先定义一个基础的对象obj，复写toString()和valueOf()方法。

        let obj = {
            toString: function () {
                console.log('调用了 obj.toString');
                return {};
            },
            valueOf: function () {
                console.log('调用了 obj.valueOf')
                return 123;
            }
        }

3.1 直接输出对象

直接 alert(obj)，输出：调用了 obj.toString ；调用了 obj.valueOf。
修改toString返回值为基础数据类型，valueOf返回值保持不变。

        obj.toString = function () {
            console.log('调用了 obj.toString');
            return 'aaa'
        };

alert(obj)，输出：调用了 obj.toString 。并没有调用valueOf()。
得出结论：
直接输出对象时，先调用其toString方法，若toString返回原始值就直接返回，否则继续调用valueOf方法，若valueOf返回不是原始类型，报错。
注意：由于这种场景先调用toString，在调用valueOf，若调用valueOf返回值为对象，会报错。（所以就不举例说明toString和valueOf返回都为对象的情况了）

3.2 对象参与运算

直接 alert(obj+‘1’)/ alert(obj+1)/alert(obj+true);，输出：只调用了 obj.valueOf。
直接 alert(obj==‘1’)，输出：只调用了 obj.valueOf。
修改valueOf返回值为对象，toString返回值保持不变。

     obj.valueOf = function () {
            console.log('调用了 obj.valueOf');
            return [];
        }

alert(obj+1)，输出：调用了 obj.valueOf。调用了 obj.toString 。并且报错Uncaught TypeError: Cannot convert object to primitive value。
修改valueOf返回值为对象，再修改toString返回值为基础数据类型。

       obj.toString = function () {
            console.log('调用了 obj.toString');
            return 'aaa';
        }
        obj.valueOf = function () {
            console.log('调用了 obj.valueOf');
            return [];
        }

alert(obj+1)，输出：调用了 obj.valueOf。调用了 obj.toString 。不报错。
得出结论：
对象参与运算时，先调用其valueOf方法，若valueOf返回原始值就直接返回，否则继续调用toString方法，若toString返回不是原始类型，报错。

另外注意，===运算，俩个都不调用，是个例外。
终上所述，这两个方法在不同使用场景会有不同的优先级：
正常情况下，
优先调用toString()，有运算操作符的情况下valueOf()的优先级高于toString()；
当调用valueOf()方法无法运算后还是会再调用toString()方法;
当调用toString()方法无法的的原始类型后还是会再调用valueOf()方法。