Bagaimana untuk memeriksa apakah sebuah objek adalah sebuah array?

Metode yang diberikan dalam ECMAScript standar untuk menemukan kelas Objek adalah dengan menggunakan toString metode dari Objek.prototipe`.

if( Object.prototype.toString.call( someVar ) === '[object Array]' ) {
    alert( 'Array!' );
}

Atau anda bisa menggunakan jenis untuk menguji jika itu adalah sebuah String:

if( typeof someVar === 'string' ) {
    someVar = [ someVar ];
}

Atau jika anda're tidak peduli tentang kinerja, anda hanya bisa melakukan concat ke new Array kosong.

someVar = [].concat( someVar );

Ada's juga konstruktor mana anda dapat query langsung:

if (somevar.constructor.name == "Array") {
    // do something
}

Check out perawatan menyeluruh dari @T. J. Crowder's blog, seperti yang diposting di komentar di bawah ini.

Check out ini benchmark untuk mendapatkan gambaran metode mana yang berkinerja lebih baik: http://jsben.ch/#/QgYAV

Dari @Bharath mengkonversi string ke array menggunakan Es6 untuk pertanyaan yang diajukan:

const convertStringToArray = (object) => {
   return (typeof object === 'string') ? Array(object) : object 
}

misalkan:

let m = 'bla'
let n = ['bla','Meow']
let y = convertStringToArray(m)
let z = convertStringToArray(n)
console.log('check y: '+JSON.stringify(y)) . // check y: ['bla']
console.log('check y: '+JSON.stringify(z)) . // check y: ['bla','Meow']

Saya akan periksa dulu jika anda mendukung pelaksanaan isArray:

if (Array.isArray)
    return Array.isArray(v);

Anda juga bisa mencoba menggunakan instanceof operator

v instanceof Array

Di browser modern yang dapat anda lakukan

Array.isArray(obj)

(Didukung oleh Chrome 5, Firefox 4.0, IE 9, Opera 10.5 dan Safari 5)

Untuk kompatibilitas, anda dapat menambahkan kode berikut

# only implement if no native implementation is available
if (typeof Array.isArray === 'undefined') {
  Array.isArray = function(obj) {
    return Object.prototype.toString.call(obj) === '[object Array]';
  }
};

Jika anda menggunakan jQuery, anda dapat menggunakan jQuery.isArray(obj) atau $.isArray(obj). Jika anda menggunakan garis bawah anda dapat menggunakan _.isArray(obj)

Jika anda don't perlu untuk mendeteksi array yang dibuat dalam frame yang berbeda anda juga dapat hanya menggunakan instanceof

obj instanceof Array

jQuery juga menawarkan sebuah $.isArray() metode:

var a = ["A", "AA", "AAA"];

if($.isArray(a)) {
  alert("a is an array!");
} else {
  alert("a is not an array!");
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

Ini adalah yang tercepat di antara semua metode (semua browser yang didukung):

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

Bayangkan anda memiliki ini array di bawah ini:

var arr = [1,2,3,4,5];

Javascript (baru dan browser yang lebih tua):

function isArray(arr) {
  return arr.constructor.toString().indexOf("Array") > -1;
}

atau

function isArray(arr) {
  return arr instanceof Array;
}

atau

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

kemudian menyebutnya seperti ini:

isArray(arr);

Javascript (IE9+, Ch5+, FF4+, Saf5+, Opera10.5+)

Array.isArray(arr);

jQuery:

$.isArray(arr);

Sudut:

angular.isArray(arr);

Menggarisbawahi dan Lodash:

_.isArray(arr);

Array.isArray bekerja cepat, tapi itu bukan't didukung oleh semua versi browser. Jadi anda bisa membuat pengecualian bagi orang lain dan menggunakan metode universal:

    Utils = {};    
    Utils.isArray = ('isArray' in Array) ? 
        Array.isArray : 
        function (value) {
            return Object.prototype.toString.call(value) === '[object Array]';
        }

Fungsi sederhana untuk memeriksa ini:

function isArray(object)
{
    if (object.constructor === Array) return true;
    else return false;
}

Ada's hanya satu line solusi untuk pertanyaan ini

x instanceof Array

di mana x adalah variabel itu akan mengembalikan true jika x adalah sebuah array dan false jika tidak.

Sebagai MDN kata di sini:

menggunakan Array.isArray atau Objek.prototipe.toString.panggilan untuk membedakan benda-benda biasa dari array

Seperti ini:

• Objek.prototipe.toString.panggilan(arr) === '[Array object]', atau

• Array.isArray(arr)

Saya akan membuat fungsi untuk menguji jenis objek yang anda berurusan dengan...

function whatAmI(me){ return Object.prototype.toString.call(me).split(/\W/)[2]; }

// tests
console.log(
  whatAmI(["aiming","@"]),
  whatAmI({living:4,breathing:4}),
  whatAmI(function(ing){ return ing+" to the global window" }),
  whatAmI("going to do with you?")
);

// output: Array Object Function String

maka anda bisa menulis sederhana jika pernyataan...

if(whatAmI(myVar) === "Array"){
    // do array stuff
} else { // could also check `if(whatAmI(myVar) === "String")` here to be sure
    // do string stuff
}

Anda dapat memeriksa jenis variabel apakah itu adalah sebuah array dengan;

var myArray=[];

if(myArray instanceof Array)
{
....
}

Ini adalah upaya saya untuk memperbaiki jawaban ini dengan mempertimbangkan komentar:

var isArray = myArray && myArray.constructor === Array;

Hal itu akan menyingkirkan if/else, dan account untuk kemungkinan array menjadi null atau tidak terdefinisi

Saya melakukan hal ini dalam cara yang sangat sederhana. Bekerja untuk saya. Kelemahan?

Array.prototype.isArray = true;

a=[]; b={};
a.isArray  // true
b.isArray  // (undefined -> false)

https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/isArray

Array.isArray = Array.isArray || function (vArg) {
    return Object.prototype.toString.call(vArg) === "[object Array]";
};

Saya telah diperbarui jsperf biola dengan dua metode alternatif serta memeriksa kesalahan.

Ternyata metode ini menentukan nilai konstan di 'Objek' dan 'Array' prototipe yang lebih cepat daripada metode lain. Hal ini agak mengejutkan hasilnya.

/* Initialisation */
Object.prototype.isArray = function() {
  return false;
};
Array.prototype.isArray = function() {
  return true;
};
Object.prototype._isArray = false;
Array.prototype._isArray = true;

var arr = ["1", "2"];
var noarr = "1";

/* Method 1 (function) */
if (arr.isArray()) document.write("arr is an array according to function<br/>");
if (!noarr.isArray()) document.write("noarr is not an array according to function<br/>");
/* Method 2 (value) - **** FASTEST ***** */
if (arr._isArray) document.write("arr is an array according to member value<br/>");
if (!noarr._isArray) document.write("noarr is not an array according to member value<br/>");

Kedua metode ini tidak bekerja jika variabel mengambil nilai tak terdefinisi, tapi mereka melakukan pekerjaan jika anda yakin bahwa mereka memiliki nilai. Berkaitan dengan pemeriksaan dengan kinerja dalam pikiran jika nilai array atau nilai tunggal, kedua metode ini tampak seperti yang valid metode cepat. Itu adalah sedikit lebih cepat dari 'instanceof' pada Chrome, dua kali lebih cepat sebagai terbaik kedua metode di Internet Explorer, Opera, dan Safari (di komputer saya).

Aku tahu, bahwa orang-orang yang mencari beberapa jenis baku javascript pendekatan. Tetapi jika anda ingin berpikir sedikit tentang, lihat di sini: http://underscorejs.org/#isArray

_.isArray(object) 

Mengembalikan true jika object adalah sebuah Array.

(function(){ return _.isArray(arguments); })();
=> false
_.isArray([1,2,3]);
=> true

Berikut dapat digunakan jika anda tahu bahwa anda objek doesn't memiliki concat metode.

var arr = []; if (typeof arr.concat === 'fungsi') { konsol.log("It's array"); }

Berikut ini's my malas pendekatan:

if (Array.prototype.array_ === undefined) {
  Array.prototype.array_ = true;
}

// ...

var test = [],
    wat = {};

console.log(test.array_ === true); // true
console.log(wat.array_ === true);  // false

Aku tahu itu's penistaan untuk "main-main dengan" prototipe, tetapi itu muncul untuk melakukan yang lebih baik secara signifikan dari yang dianjurkan toString metode.

Catatan: perangkap dari pendekatan ini adalah bahwa hal itu tidak bekerja di iframe boundariestapi bagi saya hal ini tidak menjadi masalah.

Solusi terbaik saya've terlihat adalah cross-browser pengganti typeof. Cek Angus Croll's solusi di sini.

TL;DR versi di bawah ini, tapi artikel ini adalah pembahasan masalah sehingga anda harus membaca ini jika anda memiliki waktu.

Object.toType = function(obj) {
    return ({}).toString.call(obj).match(/\s([a-z|A-Z]+)/)[1].toLowerCase();
}
// ... and usage:
Object.toType([1,2,3]); //"array" (all browsers)

// or to test...
var shouldBeAnArray = [1,2,3];
if(Object.toType(shouldBeAnArray) === 'array'){/* do stuff */};