数据类型的检测

数据类型检测

typeof 用来检测数据类型的运算符

• 使用typeof 监测数据类型，首先返回都是一个字符串
  
  • 其次字符串中包含了对应的数据类型
  • 例如： “number” –> number “string” “boolean” “undefined” “function” “object”

• 局限性：

  • –> typeof null –> “object” 是没有的
  • –> 不能具体的细分是数组还是正则，还是对象中其他的值
  • –> 因为使用typeof监测数据类型，对于对象数据类型中的左右的值，最后返回的都是”object”

• 逻辑或 || 逻辑与 && 代替typeof

            //1、typeof 用来检测数据类型的运算符
//             console.log(typeof 12); // number
//              var str = "elle";
//             console.log(typeof str); // string
//             console.log(typeof null); // object

             //使用typeof 监测数据类型，首先返回都是一个字符串
             //其次字符串中包含了对应的数据类型
             //例如： "number" --> number   "string" "boolean" "undefined" "function" "object"
             //局限性：
             // --> typeof null --> "object"  是没有的
             // --> 不能具体的细分是数组还是正则，还是对象中其他的值
             //         --> 因为使用typeof监测数据类型，对于对象数据类型中的左右的值，最后返回的都是"object"

             // 逻辑或 || 逻辑与 && 代替typeof
//             function fn(num1,num2) {
////                 if (typeof num2 === "undefined") {
////                     num2 = 0;
////                 }
//                    num2 = num2 || 0;
//             }
//             fn(10,false);
//             
//             function fn(callback) {
//                 typeof callback === "function" ? callback() : null;
//                 callback && callback(); // --> && --> 如果左边为真，则可以执行右边callback(),如果左边为假，不执行
//             }
//             fn(function () {
//                 
//             });


             //面试题：
//             console.log(typeof typeof typeof function () {}); // --> "string"

instanceof 检测某一个实例是否属于某个类

• 可以用来检测是数组还是正则，还是对象中其他的值

• –> 局限性 (so on)

  • 不能用来检测和处理字面量方式创建出来的基本数据类型的值

    • –> 对于基本数据类型来说，字面量方式创建出来的结果和实例方式创建出来的结果是有一定的区别的
    • –> 从严格意义上来讲，只有实例创建出来的结果才是标准的对象数据类型值，也是标准的Number这个类的实例
    • –> 对于字面量方式创建出来的结果是基本数据类型值，不是严谨的实例，但是由于JS的松散特点，导致了可以使用Number.prototype上提供的方法

  • instanceof的特性：只要在当前实例的原型链上，我们用其检测出来的结果都是true

<script type="text/javascript">


             //2、instanceof 检测某一个实例是否属于某个类
             //可以用来检测是数组还是正则，还是对象中其他的值
//             var obj = [12,23];
//             console.log(obj instanceof Array); // --> true
//             console.log(obj instanceof RegExp); // --> false

             // --> 局限性 (so on)
//             console.log(1 instanceof Number);  // --> false
//             console.log("" instanceof String);  // --> false
//             console.log(true instanceof Boolean); // --> false 
//            console.log(new Number(1) instanceof Number); // --> true


            //不能用来检测和处理字面量方式创建出来的基本数据类型的值
            // --> 对于基本数据类型来说，字面量方式创建出来的结果和实例方式创建出来的结果是有一定的区别的
            //      --> 从严格意义上来讲，只有实例创建出来的结果才是标准的对象数据类型值，也是标准的Number这个类的实例
            //      --> 对于字面量方式创建出来的结果是基本数据类型值，不是严谨的实例，但是由于JS的松散特点，导致了可以使用Number.prototype上提供的方法
//            console.log(typeof 1);// --> number
//            console.log(typeof new Number(1)); // --> Object

            //2、instanceof的特性：只要在当前实例的原型链上，我们用其检测出来的结果都是true
//            var ary = [];
//            console.log(ary instanceof Array); // --> true
//            console.log(ary instanceof Object); // --> true
//            
//            function fn () {
//                
//            }
//            
//            console.log(fn instanceof Function); // --> true
//            console.log(fn instanceof Object); // --> true
//            function Fn() {
//                
//            }
//            var ary = new Array;
//            Fn.prototype = ary; // --> 原型继承：让子类的原型等于父类的一个实例
//            var f = new Fn;
            //f.__proto__ --> Fn.prototype -->ary.prototype --> Array.prototype --> Object.prototype;
            // --> 在类的原型继承中，我们最后检测出来的结果
//            console.log(f instanceof Array); // --> true

            // --> 自己写一个类，作用是创建一个类数组（索引和length），但是可以使用数组的方法（在它的原型链就应该有Array.prototype）

constructor 构造函数 作用和instanceof非常相似

• –> constructor 可以处理基本数据类型的检测
• –> constructor 检测Object和instanceof不一样，一般情况下是检测不了的
• 局限性：我们可以把类的原型进行重写，重写的过程中，把之前的constructor给覆盖了，这样检测出来的结果就是不准确的
• –> 对于特殊的数据类型，null和undefined，他们的所属类是Null和Undefined，但是浏览器把这两个类保护起来了，不允许我们在外面访问使用

             //3、constrcutor 构造函数  作用和instanceof非常相似
//             var obj = []; 
//             console.log(obj.constructor === Array); // --> true
//             console.log(obj.constructor === RegExp);  // --> false
//             
//             var num = 1;
//             console.log(num.constructor === Number); // --> true
//             // --> constructor 可以处理基本数据类型的检测
//             var reg = /^$/;
//             console.log(reg.constructor === RegExp); // --> true
//             console.log(reg.constructor === Object); // --> false
             // --> constructor 检测Object和instanceof不一样，一般情况下是检测不了的
             // 局限性：我们可以把类的原型进行重写，重写的过程中，把之前的constructor给覆盖了，这样检测出来的结果就是不准确的
//            function Fn() {
//                
//            }
//            Fn.prototype = new Array;
//            var f = new Fn;
//            console.log(f.constructor); // --> Array

            //--> 对于特殊的数据类型，null和undefined，他们的所属类是Null和Undefined，但是浏览器把这两个类保护起来了，不允许我们在外面访问使用

Object.prototype.toString.call() 最准确最常用的方式

• Object 所有数据类型的基类 –> 函数类型
• –> 首先通过Object原型上的toString方法，让方法执行，并且改变方法中的this关键字的指向
• –> Object.prototype.toString 它的作用是返回当前方法执行主体也就是 (方法中this)所属的类的详细信息

             //4、Object 所有数据类型的基类 --> 函数类型 Object.prototype.toString.call() 最准确最常用的方式
             // --> 首先通过Object原型上的toString方法，让方法执行，并且改变方法中的this关键字的指向
             // -->  Object.prototype.toString 它的作用是返回当前方法执行主体也就是 (方法中this)所属的类的详细信息
//             var obj = {name:"Elle"};
//             console.log(obj.toString());  // --> toString中的this是obj,返回的是obj所属类的信息
             //  --> “[object Object]”第一个object代表当前实例是对象数据类型的（这个是固定死的），第二个Object代表的是obj所属的类是Object
             // Math.toString()  --> "[object Math]"  --> toString中的this是谁 --> Math ，那么返回的是Math所属类的信息  --> "[object Math]"

//             var ary = [];
//             console.log(Object.prototype.toString.call(ary));   // --> "[object Array]"
//             console.log(Object.prototype.toString.call(/^-?(\d|[1-9]\d+)(\.d+)$/)); // --> "[object RegExp]"
//             console.log(({}).toString.call(new Date)); // --> [object Date]
//             console.log(Object.prototype.toString.call(1)); // -->[object Number]
//             console.log(Object.prototype.toString.call("Elle")); // --> [object String]
//             console.log(Object.prototype.toString.call(true)); // --> [object Boolean]
//             console.log(Object.prototype.toString.call(null)); // --> [object Null]
//             console.log(Object.prototype.toString.call(undefined)); // --> [object Undefined]
//             console.log(Object.prototype.toString.call(function () {})); // --> [object Function]

//             var ary = [];
//             console.log(Object.prototype.toString.call(ary) === "[object Array]"); // --> true

//             var reg = /^\[object Array\]$/;
//             console.log(reg.test(Object.prototype.toString.call(ary)));  // --> true

//             function Fn() {
//                
//            }
//            var ary = new Array;
//            Fn.prototype = ary; // --> 原型继承：让子类的原型等于父类的一个实例
//            var f = new Fn;
//            console.log(f instanceof Array); // --> true
//            console.log(Object.prototype.toString.call(f) === "[object Array]");  // false --> 结果正确

toString 的理解扩展

• –> 表面上看应该是转化为字符串，但是某些toString方法不仅仅是转化为字符串
• –> 对于Number、String、Boolean、Array、RegExp、Data、Function 原型上的toString方法
  * 都是把当前的数据类型转换为字符串类型（它们的作用仅仅是用来转换为字符串的）
• –> Object.prototype.toString并不是用来转换为字符串的
  
  • ({name:”elle”}).toString() –> “[object Obejct]”
  • Math.toString() –> “[object Math]”

             //5、toString的理解
             // --> 表面上看应该是转化为字符串，但是某些toString方法不仅仅是转化为字符串
             // --> 对于Number、String、Boolean、Array、RegExp、Data、Function 原型上的toString方法
             //         都是把当前的数据类型转换为字符串类型（它们的作用仅仅是用来转换为字符串的）
             // --> Object.prototype.toString并不是用来转换为字符串的
             // ({name:"elle"}).toString() --> "[object Obejct]"
             // Math.toString()  --> "[object Math]"
//             console.log((1).toString()); // --> Number.prototype.toString 转化为字符串
//             console.log((1).__proto__.__proto__.toString()); // --> Object.prtotype.toString --> [object Object]
//             (128).toString(); // 128
//             (128).toString(2); // 10000000
//             (128).toString(8); // 200
//             (128).toString(10); // 128
             // --> console.log((128).toString(2/8/10)); --> 把数字转换成二进制、八进制、十进制