วิธีตรวจสอบว่าตัวแปรเป็นอาร์เรย์หรือไม่

วิธีการข้ามเบราว์เซอร์มาตรฐาน de-facto ที่ดีที่สุดคืออะไรในการพิจารณาว่าตัวแปรใน JavaScript เป็นอาร์เรย์หรือไม่

การค้นหาเว็บมีคำแนะนำที่แตกต่างกันบางคำดีและค่อนข้างไม่ถูกต้อง

ตัวอย่างเช่นต่อไปนี้เป็นแนวทางพื้นฐาน:

function isArray(obj) {
    return (obj && obj.length);
}

อย่างไรก็ตามโปรดสังเกตว่าจะเกิดอะไรขึ้นหากอาร์เรย์ว่างเปล่าหรือ obj ไม่ใช่อาร์เรย์ แต่ใช้คุณสมบัติความยาวเป็นต้น

ดังนั้นการนำไปใช้งานใดที่ดีที่สุดในแง่ของการทำงานจริงเป็นข้ามเบราว์เซอร์และยังทำงานได้อย่างมีประสิทธิภาพ

การตรวจสอบประเภทของวัตถุใน JS ทำได้ผ่านทางinstanceofเช่น

obj instanceof Array

สิ่งนี้จะใช้ไม่ได้หากวัตถุถูกส่งข้ามขอบเขตเฟรมเนื่องจากแต่ละเฟรมมีArrayวัตถุของตัวเอง คุณสามารถแก้ปัญหานี้ได้โดยตรวจสอบคุณสมบัติ[[Class]] ภายในของออบเจ็กต์ ในการรับมันให้ใช้Object.prototype.toString()(สิ่งนี้รับประกันว่าจะทำงานโดย ECMA-262):

Object.prototype.toString.call(obj) === '[object Array]'

วิธีการทั้งสองจะใช้ได้เฉพาะกับอาร์เรย์จริงเท่านั้นไม่ใช่วัตถุที่มีลักษณะคล้ายอาร์เรย์เช่นรายการargumentsวัตถุหรือโหนด เนื่องจากวัตถุที่มีลักษณะคล้ายอาร์เรย์ทั้งหมดต้องมีlengthคุณสมบัติเป็นตัวเลขฉันจึงตรวจสอบสิ่งเหล่านี้ดังนี้:

typeof obj !== 'undefined' && obj !== null && typeof obj.length === 'number'

โปรดทราบว่าสตริงจะผ่านการตรวจสอบนี้ซึ่งอาจนำไปสู่ปัญหาเนื่องจาก IE ไม่อนุญาตให้เข้าถึงอักขระของสตริงด้วยดัชนี ดังนั้นคุณอาจต้องการที่จะเปลี่ยนtypeof obj !== 'undefined'เพื่อtypeof obj === 'object'ที่จะไม่รวมวิทยาการและวัตถุโฮสต์ที่มีชนิดที่แตกต่างจาก'object' alltogether สิ่งนี้จะยังคงปล่อยให้สตริงออบเจ็กต์ผ่านซึ่งจะต้องถูกแยกออกด้วยตนเอง

ในกรณีส่วนใหญ่สิ่งที่คุณอยากรู้คือคุณสามารถทำซ้ำบนวัตถุผ่านดัชนีตัวเลขได้หรือไม่ ดังนั้นจึงควรตรวจสอบว่าวัตถุมีคุณสมบัติที่ตั้งชื่อ0แทนหรือไม่ซึ่งสามารถทำได้ผ่านการตรวจสอบอย่างใดอย่างหนึ่งต่อไปนี้:

typeof obj[0] !== 'undefined' // false negative for `obj[0] = undefined`
obj.hasOwnProperty('0') // exclude array-likes with inherited entries
'0' in Object(obj) // include array-likes with inherited entries

การส่งไปยังออบเจ็กต์เป็นสิ่งที่จำเป็นในการทำงานอย่างถูกต้องสำหรับไพรมารีเหมือนอาร์เรย์ (เช่นสตริง)

นี่คือรหัสสำหรับการตรวจสอบอาร์เรย์ JS ที่มีประสิทธิภาพ:

function isArray(obj) {
    return Object.prototype.toString.call(obj) === '[object Array]';
}

และทำซ้ำได้ (เช่นไม่ว่างเปล่า) วัตถุคล้ายอาร์เรย์:

function isNonEmptyArrayLike(obj) {
    try { // don't bother with `typeof` - just access `length` and `catch`
        return obj.length > 0 && '0' in Object(obj);
    }
    catch(e) {
        return false;
    }
}

การมาถึงของ ECMAScript 5th Edition ทำให้เรามีวิธีทดสอบที่แน่นอนที่สุดว่าตัวแปรคืออาร์เรย์Array.isArray () :

Array.isArray([]); // true

แม้ว่าคำตอบที่ยอมรับที่นี่จะใช้ได้กับเฟรมและหน้าต่างสำหรับเบราว์เซอร์ส่วนใหญ่ แต่ก็ไม่ได้ใช้กับ Internet Explorer 7 และต่ำกว่าเนื่องจากการObject.prototype.toStringเรียกอาร์เรย์จากหน้าต่างอื่นจะส่งกลับ[object Object]ไม่ใช่[object Array]ไม่ได้ดูเหมือนว่า IE 9 จะถดถอยพฤติกรรมนี้ด้วย (ดูการแก้ไขที่อัปเดตด้านล่าง)

หากคุณต้องการโซลูชันที่ใช้ได้กับทุกเบราว์เซอร์คุณสามารถใช้:

(function () {
    var toString = Object.prototype.toString,
        strArray = Array.toString(),
        jscript  = /*@cc_on @_jscript_version @*/ +0;

    // jscript will be 0 for browsers other than IE
    if (!jscript) {
        Array.isArray = Array.isArray || function (obj) {
            return toString.call(obj) == "[object Array]";
        }
    }
    else {
        Array.isArray = function (obj) {
            return "constructor" in obj && String(obj.constructor) == strArray;
        }
    }
})();

มันไม่ได้แตกทั้งหมด แต่จะมี แต่ใครบางคนที่พยายามอย่างหนักที่จะทำลายมัน ใช้งานได้กับปัญหาใน IE7 และต่ำกว่าและ IE9 ข้อบกพร่องยังคงมีอยู่ใน IE 10 PP2แต่อาจได้รับการแก้ไขก่อนปล่อย

ปล. หากคุณไม่แน่ใจเกี่ยวกับวิธีแก้ปัญหาฉันขอแนะนำให้คุณทดสอบกับเนื้อหาในใจของคุณและ / หรืออ่านบทความในบล็อก มีวิธีแก้ปัญหาอื่น ๆ ที่เป็นไปได้หากคุณไม่สบายใจในการใช้การรวบรวมตามเงื่อนไข

คร็อกฟอร์ดมีคำตอบสองข้อในหน้า 106 ของ "ส่วนที่ดี" ตัวแรกตรวจสอบตัวสร้าง แต่จะให้เชิงลบที่ผิดพลาดในเฟรมหรือหน้าต่างต่างๆ นี่คือวินาที:

if (my_value && typeof my_value === 'object' &&
        typeof my_value.length === 'number' &&
        !(my_value.propertyIsEnumerable('length')) {
    // my_value is truly an array!
}

Crockford ชี้ให้เห็นว่าเวอร์ชันนี้จะระบุไฟล์ argumentsอาร์เรย์ว่าเป็นอาร์เรย์แม้ว่าจะไม่มีวิธีอาร์เรย์ก็ตาม

การอภิปรายปัญหาที่น่าสนใจของเขาเริ่มต้นในหน้า 105

มีการอภิปรายที่น่าสนใจเพิ่มเติม (post-Good Parts) ที่นี่ซึ่งรวมถึงข้อเสนอนี้:

var isArray = function (o) {
    return (o instanceof Array) ||
        (Object.prototype.toString.apply(o) === '[object Array]');
};

การสนทนาทั้งหมดทำให้ฉันไม่อยากรู้ว่าบางอย่างเป็นอาร์เรย์หรือไม่

jQuery ใช้ฟังก์ชัน isArray ซึ่งแนะนำวิธีที่ดีที่สุดในการดำเนินการนี้คือ

function isArray( obj ) {
    return toString.call(obj) === "[object Array]";
}

(ตัวอย่างที่นำมาจาก jQuery v1.3.2 - ปรับเล็กน้อยเพื่อให้เข้าใจผิดบริบท)

ขโมยมาจากปรมาจารย์ John Resig และ jquery:

function isArray(array) {
    if ( toString.call(array) === "[object Array]") {
        return true;
    } else if ( typeof array.length === "number" ) {
        return true;
    }
    return false;
}

คุณจะทำอย่างไรกับค่าเมื่อคุณตัดสินใจว่าเป็นอาร์เรย์

ตัวอย่างเช่นหากคุณตั้งใจจะแจกแจงค่าที่มีอยู่หากดูเหมือนอาร์เรย์หรือถ้าเป็นวัตถุที่ใช้เป็นตารางแฮชโค้ดต่อไปนี้จะได้รับสิ่งที่คุณต้องการ (โค้ดนี้จะหยุดเมื่อฟังก์ชันการปิดส่งคืนค่าอื่น ๆ กว่า "ไม่ได้กำหนด" โปรดทราบว่าจะไม่วนซ้ำบนคอนเทนเนอร์ COM หรือการแจงนับ แต่เป็นแบบฝึกหัดสำหรับผู้อ่าน):

function iteratei( o, closure )
{
    if( o != null && o.hasOwnProperty )
    {
        for( var ix in seq )
        {
            var ret = closure.call( this, ix, o[ix] );
            if( undefined !== ret )
                return ret;
        }
    }
    return undefined;
}

(หมายเหตุ: การทดสอบ "o! = null" สำหรับค่าว่างและไม่ได้กำหนด)

ตัวอย่างการใช้งาน:

// Find first element who's value equals "what" in an array
var b = iteratei( ["who", "what", "when" "where"],
    function( ix, v )
    {
        return v == "what" ? true : undefined;
    });

// Iterate over only this objects' properties, not the prototypes'
function iterateiOwnProperties( o, closure )
{
    return iteratei( o, function(ix,v)
    {
        if( o.hasOwnProperty(ix) )
        {
            return closure.call( this, ix, o[ix] );
        }
    })
}

หากคุณกำลังทำสิ่งนี้ใน CouchDB (SpiderMonkey) ให้ใช้ไฟล์

Array.isArray(array)

เป็นarray.constructor === Arrayหรือarray instanceof Arrayไม่ทำงาน การใช้array.toString() === "[object Array]"งานได้ผล แต่ดูเหมือนจะค่อนข้างหลบเมื่อเปรียบเทียบ

หากคุณต้องการเบราว์เซอร์ที่คุณต้องการjQuery.isArray

ในw3schoolมีตัวอย่างที่ค่อนข้างเป็นมาตรฐาน

เพื่อตรวจสอบว่าตัวแปรเป็นอาร์เรย์หรือไม่พวกเขาใช้สิ่งที่คล้ายกันนี้

function arrayCheck(obj) { 
    return obj && (obj.constructor==Array);
}

ทดสอบบน Chrome, Firefox, Safari, ie7

หนึ่งที่ดีที่สุดวิจัยและกล่าวถึงรุ่นของฟังก์ชั่นนี้สามารถพบได้บนเว็บไซต์ PHPJS คุณสามารถเชื่อมโยงไปยังแพ็กเกจหรือไปที่ฟังก์ชันโดยตรงก็ได้ ฉันขอแนะนำไซต์สำหรับฟังก์ชัน PHP ที่เทียบเท่าใน JavaScript

การอ้างอิงไม่เพียงพอเท่ากับตัวสร้าง บางครั้งพวกเขามีการอ้างอิงที่แตกต่างกันของตัวสร้าง ดังนั้นฉันจึงใช้การแสดงสตริงของพวกมัน

function isArray(o) {
    return o.constructor.toString() === [].constructor.toString();
}

แทนที่Array.isArray(obj)โดยobj.constructor==Array

ตัวอย่าง:

Array('44','55').constructor==Array คืนค่าจริง (IE8 / Chrome)

'55'.constructor==Array ส่งคืนเท็จ (IE8 / Chrome)