原型的应用

1.基础方法

w3c不推荐直接使用系统属性

1. Object.getPrototypeOf(对象) 获取对象的隐式原型

对象.__proto__  
[[scopes]] 、 __proto__ 系统属性不能被直接调用

2. Object.prototype.isPrototypeOf(指定对象) 判断当前对象是否在指定的对象的原型链上

3. 对象 instanceof 函数：判断函数的原型在不在对象的原型链上 (对象是不是某个东西)

4. Object.Create(对象) ：创建一个空对象，并且将对象的隐式原型修改为指定的参数
   在创建一个对象时，可以修改隐式原型，但是不要修改为null

5. Object.prototype.hasOwnProperty(属性名)：判断属性名是不是对象自身的

属性描述符：*扩展*
对每个属性进行设置：是否可读、可写、……

2.将伪数组转换为真数组

Array.prototype.slice.call(伪数组)	//转换为真数组

// 调用了数组原型上slice方法,通过call将slice中this的指向改变为lis
// slice方法中操作的对象是  lis伪数组
// 没有给slice传递任何截取的参数 所有将lis中所有的数据取出放入新数组，然后返回这个新数组

Array.from(伪数组)//转换为真数组

3. 如何判断一个数组是不是真数组

Array.isArray(伪数组)	 // 判断一个数据是否是数组  isArray()  静态方法  ES5
// Array.isArray(需要判断的数据)  返回一个boolean值

// 1. ES5之前判断一个数据是否是数组 isPrototypeOf
Array.prototype.isPrototypeOf(lis)  // 是不是一个真数组 返回一个boolean值


**小扩展1：**
// 创建一个对象有几种方法？
        // 1. 
        var obj = {}
        // 2. 
        var obj = new Object()
        // 3. 
        var obj = Object.create()   


**小扩展2：**
// for in:会遍历出对象隐式原型上的属性

        // var obj = {
        //     name:"张健",
        //     age:18
        // }

        var obj = Object.create({x:1,y:2})
        obj.name = "张健";
        obj.age = 18;

        for(var key in obj){
            // 当只需操作对象本身的属性时，去判断一下这些属性是否是对象自身的属性
            if(obj.hasOwnProperty(key)){
                console.log(key);
            }
            
        }

4.判断数据类型

var obj = {};
        var arr = [];
        // get:获取，得到
        // set：设置
        //1.  getPrototypeOf 获取对象的隐式原型
        console.log(Object.getPrototypeOf(obj) === Array.prototype);// false
        console.log(Object.getPrototypeOf(arr) === Array.prototype);// true

				//与上面等同
				console.log(obj.__proto__ === Array.prototype);// false
				console.log(arr.__proto__ === Array.prototype);// true

        // 2.通过对象的构造函数判断
        console.log(obj.constructor === Array)
        console.log(arr.constructor === Array)

        // 3. instanceof
        console.log(obj instanceof Array); // false
        console.log(arr instanceof Array); // true

        // 4. 检测内部属性class  toString()会在所有的构造函数的原型上被重写
        // 只有Object.prototype.toString()才能检测数对象的数据类型

        var str = '123456';
        // 原始类型有没有属性和方法？没有
        str.toString();  // 调用的是哪个原型的toString() String.prototype.toString()
        // 所有的数据在调用toString()时，调用的都是自身构造函数原型上的toString()
        // 让所有的数据去调用 Object.prototype.toString()
        // ({a:1}).toString()
        console.log(Object.prototype.toString.call(123));//[object Number]
        console.log(Object.prototype.toString.call(function(){}));//[object Function]
        console.log(Object.prototype.toString.call(new Date()));//[object Date]
        console.log(Object.prototype.toString.call([1,2,3]) === '[object Array]');//true

5.toString()与valueof

 // toString() : 默认返回一个字符串，在Object的原型上，toString返回'[object Object]' 验证数据类型
        // 在所有的原型上都被重写了
        var obj = {
            a:1,
            toString:function(){
                return 123;
            }
        }
        console.log(obj.toString()); // 123
        // valueOf() ：得到某个对象的原始值
        // 将一个对象尽可能的转换为原始值(number,string,boolean)
        // console.log(obj.valueOf());
        // console.log(new Number(123).valueOf());

        // var obj = {
        //     name:1
        // }

        // console.log(obj + 1);  // '[object Ojbect]' + 1 => '[object Ojbect]1'
        // 用对象做运行，会自动进行类型转换，先调用valueOf(),再去调用自身的toString(),然后参与运算。
        // 如果调用valueOf之后，得到的是原始类型的数据，就不会再去调用toString()

        var obj = {
            name:1,
            // toString:function(){
            //     return '123';
            // },
            valueOf:function(){
                return {};
            }
        }
        console.log(obj + 1); // 124

结论：用对象做运算，会自动进行类型转换，先调用valueOf(),再去调用自身的toString(),然后参与运算。
如果调用valueOf之后，得到的是原始类型的数据，就不会再去调用toString()