精华内容
下载资源
问答
  • 判断是否是数组的几种方法

    千次阅读 2018-05-15 23:58:36
    判断objectName是否是数组1、objectName instanceof Array2、objectName.constructor == Array基本数据类型也可以使用此方法。(123).constructor == Number // true11、2判断有误差。 a)在不同 iframe 中创建 ...

    判断objectName是否是数组

    1、objectName instanceof Array

    2、objectName.constructor == Array

    基本数据类型也可以使用此方法。

    (123).constructor == Number // true
    • 1

    1、2判断有误差。 
    a)在不同 iframe 中创建的 Array 并不共享 prototype 
    b)即使为true,也有可能不是数组。 
    function SubArray(){ 

    SubArray.prototype = []; 
    myArray = new SubArray; 
    alert(myArray instanceof Array)

    3、特性判断

    a)length 
    b)splice 
    c)length不可枚举

        function isArray(object){
        return  object && typeof object==='object' &&    
                typeof object.length==='number' &&  
                typeof object.splice==='function' &&    
                 //判断length属性是否是可枚举的 对于数组 将得到false  
                !(object.propertyIsEnumerable('length'));
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    有length和splice并不一定是数组,因为可以为对象添加属性,而不能枚举length属性,才是最重要的判断因子。

    4、Array.isArray(objectName);

    ES5方法

    5、Object.prototype.toString.call(objectName)

    获取this对象的[[Class]]属性的值.[Class]]是一个内部属性,所有的对象都拥有该属性. 表明该对象的类型 
    Object.prototype.toString.call(objectName) === ‘[object Array]‘;

    展开全文
  • 对于一些基本类型,typeof是可以判断出数据类型,但是判断一些引用类型时候,不能具体到具体哪一类型 再来复习一下typeof用法: // 基本类型 typeof 123; //number typeof "123"; //string typeof true; //...
        

    1. 首先,typeof肯定是不行的

    对于一些基本类型,typeof是可以判断出数据类型,但是判断一些引用类型时候,不能具体到具体哪一种类型
    再来复习一下typeof的用法:

    // 基本类型
    typeof 123;  //number
    typeof "123"; //string
    typeof true; //boolean
    typeof undefined; //undefined
    typeof null; //object
    let s = Symbol;
    typeof s; //symbol
    
    // 引用类型
    typeof [1,2,3]; //object
    typeof {}; //object
    typeof function(){}; //function
    typeof  Array; //function  Array类型的构造函数
    typeof Object; //function  Object类型的构造函数
    typeof Symbol; //function  Symbol类型的构造函数
    typeof Number; //function  Number类型的构造函数
    typeof String; //function  String类型的构造函数
    typeof Boolean; //function  Boolean类型的构造函数
    

    2. 两种简单,但是不是十分准确的方法

    var obj = [4,67,23];
    obj instanceof Array; //return true 
    obj.constructor == Array; // return true

    为什么不准确?

    2.1 首先来复习一下instanceof用法

    判断一个实例是否属于某种类型

    function Foo(name) {
        this.name = name;
    }
    var f = new Foo('zhangsan');
    console.log(f instanceof Foo); //true
    console.log(f instanceof Object); //true

    判断一个实例是否属于它的父类型

    function Person() {};
    function Student() {};
    var p = new Person();
    Student.prototype = p;
    var s = new Student();
    console.log(s instanceof Student); //true
    console.log(s instanceof Person); //true
    
    记忆:
    A instanceof C   等价于  A 是否是 C子类,或者后代?

    2.2 instanceof 判断逻辑?

    判断逻辑翻译成js代码如下:

    _instanceof(f, Foo);  
    
    function _instanceof(L, R) {
        var R = o.prototype;
        var L = L.__proto__;
        while( true) {
            if(L == null) {
                return false;
            }
            if(L == R) {
                return true;
            }
            L = L.__proto__;
        }
    }

    2.3 instanceof 不准确的原因?

    代码如下:

        var iframe = document.createElement('iframe');
        document.body.appendChild(iframe);
    
        var arr = [1,2,3];
        xArray = window.frames[0].Array;  //iframe中的构造函数
        var arrx = new xArray(4,5,6);
    
        console.log(arrx instanceof Array);  //false
        console.log(arrx.constructor == Array);// false
    
        console.log(Array.prototype == xArray.prototype); //false
        console.log(arr instanceof xArray); //false
    
        console.log(arrx.constructor === Array);// false
        console.log(arr.constructor === Array);// true
        console.log(arrx.constructor === xArray);// true
        console.log(Array.isArray(arrx));  //true

    解释:红宝书,p88

    instanceof操作符的问题在于,它假定只有一个全局环境。如果网页中包含多个框架,那实际上就存在两个以上不同的全局执行环境,从而存在两个以上不同版本的Array构造函数。
    如果你从一个框架向另一个框架传入一个数组,那么传入的数组与在第二个框架中原生创建的数组分别具有各自不同的构造函数。

    2.4 constructor 不准确的原因?

    因为constructor可以被重写,所以不能确保一定是数组
    example:

        var str = 'abc';
        str.constructor = Array;
        str.constructor === Array // return true

    而很明显str不是数组。
    而且constructor和instanceof存在同样问题,不同执行环境下,constructor判断不正确问题。

    3. isArray()

    最终确定某个值到底是不是数组,而不管它是在哪个全局执行环境中创建的,这个方法的用法如下。

    if(Array.isArray(value)){
        return true;
    }

    4. Object.prototype.toString

    如果在尚未实现isArray方法的浏览器中准确监测数组,我们需要用到Object.prototype.toString方法来判断,每一个继承自Object的对象都拥有toString的方法。

    if(!Array.isArray){
        Array.isArray = function(arg){
            return Object.prototype.toString.call(arg)==='[object Array]'
        }
    
    }

    自己可以封装一个获取变量类型的函数

    function getType(obj) {
        return Object.prototype.toString.call(obj).slice(8,-1);
    }
    
    var a = [1,2,3];
    console.log(getType(a)); //Array 
    
    var b = function(){};
    console.log(getType(b)); //Function

    5. 参考文章

    JavaScript instanceof 运算符深入剖析
    javascript 判断变量是否是数组(Array)

    展开全文
  • 方法判断对象是不是数组是用最多也是最严格  class值记录创建时类型  console.log(Object.prototype.toString.call(obj1)=="[object Array]");  console.log(Object.prototype.toString.call(obj2...
        var obj1={};
        var obj2=[1,2,3];
        var obj3=function(){};
        var obj4={}; obj4.__proto__=[];


        1、isPrototypeOf 不但检查直接父对象,而且检查整个原型链
      

     console.log(Array.prototype.isPrototypeOf(obj1));//f
     console.log(Array.prototype.isPrototypeOf(obj2));//t
     console.log(Array.prototype.isPrototypeOf(obj3));//t
     console.log(Array.prototype.isPrototypeOf(obj4));//t

        2、instanceof 可检查整个原型链 判断是不是构造函数的实例
        

        console.log(obj1 instanceof Array);
        console.log(obj2 instanceof Array);
        console.log(obj3 instanceof Array);
        console.log(obj4 instanceof Array);


        3、constructor 可检查整个原型链

        console.log(obj1.constructor==Array);
        console.log(obj2.constructor==Array);
        console.log(obj3.constructor==Array);
        console.log(obj4.constructor==Array);


        4、调用原生toString()方法访问对象内部的class属性
        call(替代this对象) call做2件事1、执行函数2、替换this
        此方法判断对象是不是数组是用的最多的也是最严格的 
        class值记录创建时的类型

        console.log(Object.prototype.toString.call(obj1)=="[object Array]");
        console.log(Object.prototype.toString.call(obj2)=="[object Array]");
        console.log(Object.prototype.toString.call(obj3)=="[object Array]");
        console.log(Object.prototype.toString.call(obj4)=="[object Array]");
     /**
     * Returns internal [[Class]] property of an object
     *
     * Ecma-262, 15.2.4.2
     * Object.prototype.toString( )
     *
     * When the toString method is called, the following steps are taken: 
     * 1. Get the [[Class]] property of this object. 
     * 2. Compute a string value by concatenating the three strings "[object ", Result (1), and "]". 
     * 3. Return Result (2).
     */
    function __getClass(object){
     return Object.prototype.toString.call(object).match(/^\[object\s(.*)\]$/)[1];
    };
    var ary = new Array();
    var x = __getClass(ary);
    //var reg=/[0-9]{1}/;
    //var x = __getClass(reg);//RegExp
    console.log(x);


        5、Array.isArray(obj)方法 ECMA5新标准 旧的浏览器不支持的话就添加

        console.log(Array.isArray(obj1));
        console.log(Array.isArray(obj2));
        console.log(Array.isArray(obj3));
        console.log(Array.isArray(obj4));

     

    转载于:https://my.oschina.net/wangch5453/blog/674346

    展开全文
  • 判断一个对象是否是数组类型的几种方法 -----判断一个类型是不是数组一共有8种方法,如下: var obj1={},obj2=[1,2,3],obj3=new Date(); 1.通过此对象的爹判断是不是数组的原型对象 console.log(//通过此对象的爹...

    判断一个对象是否是数组类型的几种方法

    -----判断一个类型是不是数组一共有8种方法,如下:
    var obj1={},obj2=[1,2,3],obj3=new Date();
    1.通过此对象的爹判断是不是数组的原型对象
    console.log(//通过此对象的爹判断是不是数组的原型对象
    obj1.proto==Array.prototype,
    obj2.proto==Array.prototype,//true 为数组
    obj3.proto==Array.prototype
    )
    2.判断obj的原型对象是不是数组的原型对象
    console.log(// ,obj的原型对象是不是数组的原型对象
    Object.getPrototypeOf(obj1)==Array.prototype,
    Object.getPrototypeOf(obj2)==Array.prototype,
    Object.getPrototypeOf(obj3)==Array.prototype
    )
    //3.一个更直接函数 father.isPrototypeOf(child)
    console.log(//数组的原型对象是obj的原型对象吗?
    Array.prototype.isPrototypeOf(obj1),
    Array.prototype.isPrototypeOf(obj2),
    Array.prototype.isPrototypeOf(obj3),
    )

    //4。通过寻找是不是继承Array直接判断
    //父级元素中的canstructor
    console.log(//判断由子元素找回父亲再找回母亲是不是Array
    obj1.constructorArray,// obj1.proto.constructorArray,
    obj2.constructorArray,
    obj3.constructor
    Array
    )
    //5.用 ”child instanceof 妈妈“
    // 实列
    console.log( //孩子(obj) 是妈妈(Array)的孩子吗?(//判断 obj 是不是Array new出来的)
    obj1 instanceof Array,
    obj2 instanceof Array,
    obj3 instanceof Array,
    )
    //6.输出对象的DNA:内部隐藏属性class
    console.log(
    Object.prototype.toString.call(obj1),//将obj强行打入顶级父元素去调用顶级父元素的toString()函数
    Object.prototype.toString.call(obj2),
    Object.prototype.toString.call(obj3)
    )
    //7 ES5!!!
    console.log(
    Array.isArray(obj1),
    Array.isArray(obj2),
    Array.isArray(obj3),
    )
    //8
    console.log(
    obj1.constructor.toString(),
    obj2.constructor.toString(),
    obj3.constructor.toString(),
    )

    如下:
    // console.log(
    // obj2.proto==Array.prototype,
    // Object.getPrototypeOf(obj2)Array.prototype,
    // Array.prototype.isPrototypeOf(obj2),
    // obj2.constructor
    Array,
    // obj2 instanceof Array,
    // Object.prototype.toString.call(obj2),
    // Array.isArray(obj2),
    // obj2.constructor.toString()
    // )

    结果:
    true
    true
    true
    true
    true
    “[object Array]”
    true
    “function Array() { [native code] }”

    展开全文
  • 判断是否是数组和对象的几种方法

    千次阅读 2019-02-27 19:21:23
    使用typeof来检测数据类型,但是对于Function, String, Number, Undefined等这几种基本类型来说,使用typeof来检测都可以检测到,比如代码如下: function test(){} console.log(typeof 1); // number console....
  • 下面列举几种常见的判断是否为真数组的几种方法 起手式:定义一个类数组和真数组 <div></div> <div></div> <div></div> <script> var divs = document....
  • 判断数组的几种方法

    2019-09-25 13:15:24
    判断数组的几种方法 instanceof运算符 这个运算符可以判断一个对象是否是在其原型链上原型构造函数中的属性。 let arr = []; console.log(arr instanceof Array); //true constructor 这个属性是返回对象相对应的...
  • 1.instanceof 判断一个对象是否是由某个类型创建出来  obj instanceof Array = true //则表示是数组2.Object.prototype.toString()方法  Object.prototype.toString.call(arr) == [object Array] 3.Array....
  • 判断是否是对象 1.toString 方式【常用】 Object.prototype.toString.call(val) === '[object Object]' 注意:这里要使用 call 方法改变作用域 2.constructor 方式 val?.constructor === Object 这里使用...
  • 声明一个数组array,一个待测试元素var ...接下来用几种方法来分别测试var是否是array中元素 判断方法1: echo "${array[@]}" | grep -wq "$var" && echo "Yes" || echo "No" 判断方法2: fo...
  • PHP判断数组为空方法1:count($arr); count 如果输出为0话 ...用implode()将数组输出为字符串,判断输出字串是否为空。初看上去似乎是个不错的方法,可惜跟上一点一样,对于二维以上数组就不行了。 $arr= array(a
  • 今天完成一个算法的过程中,有个需求模块,其中就有判断$a数组是否是$b数组的子集,可能最近我写c比较多,直接就用for循环实现了,但是感觉代码量比较大,不够优雅!在qq群里集思广益了一下,发现很多php提供的...
  • 有好几种方法 总结一下1:array.indexOf 此方法判断数组是否存在某个值,如果存在返回数组元素下标,否则返回-1let arr = ['something', 'anything', 'nothing', 'anything'];let index = arr.indexOf('nothing'...
  • // true 用于确定传递是否是一个Array instanceof console.log([1,2] instanceof Array); // true 当检测Array实例时,Array.isArray优于instanceof,因为Array.isArray能检测iframes。参考...
  • 下面这些方法是判断数组的几种方法: 1、instanceof运算符 主要是判断某个实例(arr)是否属于某个对象。 let arr = [1,2,3]; console.log(arr instanceof Array); //true 2、constructor 判断实例(arr)的构造函数...
  • 二、判断对象是否是数组的几种方式 1.通过instanceof判断 instanceof运算符用于检验构造函数的prototype属性是否出现在对象的原型链中的任何位置,返回一个布尔值。 let a = []; a instanceof Array; //true let b...
  • 数组去重的几种方法

    2021-04-24 16:52:34
    数组去重是一个非常常见问题,虽然前端一般并不会处理这样数据,但是如果有需求话,那我们就必须要做出来,这里提供几种方法。 1.for循环 原理是用for循环遍历数组判断是否有相同值,如果有,则删除...
  • 检测数组的6种方法

    2020-12-09 10:29:07
    下面这些方法是判断数组的几种方法: 1、instanceof运算符 主要是判断某个实例(arr)是否属于某个对象。 let arr = [1,2,3]; console.log(arr instanceof Array); //true 2、constructor 判断实例(arr)的构造...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 446
精华内容 178
关键字:

判断是否是数组的几种方法