Bagaimana mendeteksi apakah suatu variabel adalah array

Apa metode lintas-browser standar de-facto terbaik untuk menentukan apakah variabel dalam JavaScript adalah larik atau bukan?

Mencari di web ada sejumlah saran berbeda, beberapa bagus dan beberapa tidak valid.

Misalnya, berikut ini adalah pendekatan dasar:

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

Namun, perhatikan apa yang terjadi jika array kosong, atau obj sebenarnya bukan array tetapi mengimplementasikan properti panjang, dll.

Jadi penerapan mana yang terbaik dalam hal benar-benar berfungsi, bersifat lintas-browser, dan masih berkinerja efisien?

Pemeriksaan jenis objek di JS dilakukan melalui instanceof, yaitu

obj instanceof Array

Ini tidak akan berfungsi jika objek melewati batas bingkai karena setiap bingkai memiliki Arrayobjeknya sendiri . Anda bisa menyiasatinya dengan memeriksa properti internal [[Class]] dari objek. Untuk mendapatkannya, gunakan Object.prototype.toString()(ini dijamin bekerja oleh ECMA-262):

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

Kedua metode hanya akan bekerja untuk array yang sebenarnya dan bukan objek seperti array seperti argumentsobjek atau daftar node. Karena semua objek yang mirip array harus memiliki lengthproperti numerik , saya akan memeriksanya seperti ini:

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

Harap dicatat bahwa string akan melewati pemeriksaan ini, yang dapat menyebabkan masalah karena IE tidak mengizinkan akses ke karakter string dengan indeks. Oleh karena itu, Anda mungkin ingin mengubah typeof obj !== 'undefined'ke typeof obj === 'object'mengecualikan primitif dan benda-benda host dengan jenis yang berbeda dari 'object'alltogether. Ini akan tetap membiarkan objek string lewat, yang harus dikecualikan secara manual.

Dalam kebanyakan kasus, yang sebenarnya ingin Anda ketahui adalah apakah Anda dapat melakukan iterasi pada objek melalui indeks numerik. Oleh karena itu, sebaiknya periksa apakah objek tersebut memiliki properti bernama 0, yang bisa dilakukan melalui salah satu pemeriksaan berikut:

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

Cast to object diperlukan untuk bekerja dengan benar untuk primitif mirip-array (yaitu string).

Berikut kode untuk pemeriksaan kuat untuk array JS:

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

dan objek seperti array yang dapat diulang (yaitu tidak kosong):

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;
    }
}

Kehadiran ECMAScript Edisi ke-5 memberi kita metode pengujian paling pasti jika variabel adalah array, Array.isArray () :

Array.isArray([]); // true

Meskipun jawaban yang diterima di sini akan berfungsi di seluruh bingkai dan jendela untuk sebagian besar browser, itu tidak untuk Internet Explorer 7 dan yang lebih rendah , karena Object.prototype.toStringdipanggil pada array dari jendela yang berbeda akan kembali [object Object], bukan [object Array]. IE 9 tampaknya juga telah mundur ke perilaku ini (lihat perbaikan yang diperbarui di bawah).

Jika Anda menginginkan solusi yang berfungsi di semua browser, Anda dapat menggunakan:

(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;
        }
    }
})();

Ini tidak sepenuhnya tidak bisa dipecahkan, tetapi hanya akan dipatahkan oleh seseorang yang berusaha keras untuk memecahkannya. Ia bekerja di sekitar masalah di IE7 dan yang lebih rendah dan IE9. Bug masih ada di IE 10 PP2 , tetapi mungkin diperbaiki sebelum rilis.

NB, jika Anda tidak yakin tentang solusinya maka saya sarankan Anda mengujinya sesuka hati dan / atau membaca posting blog. Ada solusi potensial lain di sana jika Anda tidak nyaman menggunakan kompilasi bersyarat.

Crockford memiliki dua jawaban di halaman 106 dari "The Good Parts." Yang pertama memeriksa konstruktor, tetapi akan memberikan negatif palsu di seluruh bingkai atau jendela yang berbeda. Ini yang kedua:

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

Crockford menunjukkan bahwa versi ini akan mengidentifikasi argumentsarray sebagai array, meskipun tidak memiliki metode array apa pun.

Pembahasannya yang menarik tentang masalah ini dimulai pada halaman 105.

Ada diskusi menarik lebih lanjut (post-Good Parts) di sini yang meliputi proposal ini:

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

Semua diskusi membuat saya tidak pernah ingin tahu apakah sesuatu itu array atau tidak.

jQuery mengimplementasikan fungsi isArray, yang menyarankan cara terbaik untuk melakukannya adalah

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

(cuplikan diambil dari jQuery v1.3.2 - sedikit disesuaikan agar masuk akal di luar konteks)

Mencuri dari guru John Resig dan jquery:

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

Apa yang akan Anda lakukan dengan nilai setelah Anda memutuskan itu adalah array?

Misalnya, jika Anda bermaksud untuk menghitung nilai yang terkandung jika terlihat seperti larik ATAU jika itu adalah objek yang digunakan sebagai tabel hash, maka kode berikut mendapatkan apa yang Anda inginkan (kode ini berhenti ketika fungsi penutupan mengembalikan apa pun yang lain dari "undefined". Perhatikan bahwa ini TIDAK mengulang kontainer atau enumerasi COM; yang tersisa sebagai latihan untuk pembaca):

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;
}

(Catatan: pengujian "o! = Null" untuk null & undefined)

Contoh penggunaan:

// 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] );
        }
    })
}

Jika Anda melakukan ini di CouchDB (SpiderMonkey), gunakan

Array.isArray(array)

sebagai array.constructor === Arrayatau array instanceof Arraytidak bekerja. Menggunakan array.toString() === "[object Array]"memang berhasil tetapi tampaknya cukup cerdik jika dibandingkan.

Jika Anda ingin lintas-browser, Anda menginginkan jQuery.isArray .

Di w3school ada contoh yang seharusnya cukup standar.

Untuk memeriksa apakah suatu variabel adalah array mereka menggunakan sesuatu yang mirip dengan ini

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

diuji di Chrome, Firefox, Safari, ie7

Salah satu versi terbaik yang diteliti dan didiskusikan dari fungsi ini dapat ditemukan di situs PHPJS . Anda dapat menautkan ke paket atau Anda dapat langsung membuka fungsinya . Saya sangat merekomendasikan situs ini untuk konstruksi yang setara dengan fungsi PHP di JavaScript.

Referensi tidak cukup sama dengan konstruktor. Terkadang mereka memiliki referensi konstruktor yang berbeda. Jadi saya menggunakan representasi string dari mereka.

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

Gantikan Array.isArray(obj)denganobj.constructor==Array

sampel:

Array('44','55').constructor==Array kembalikan true (IE8 / Chrome)

'55'.constructor==Array kembali salah (IE8 / Chrome)