Bagaimana cara memeriksa apakah suatu objek adalah array?

Saya mencoba menulis fungsi yang dapat menerima daftar string, atau string tunggal. Jika ini sebuah string, maka saya ingin mengonversinya menjadi sebuah array hanya dengan satu item, jadi saya dapat mengulanginya tanpa takut ada kesalahan.

Jadi bagaimana cara saya memeriksa apakah variabel adalah array?

Saya telah mengumpulkan berbagai solusi di bawah ini dan membuat tes jsperf . Mereka semua cepat, jadi gunakan saja Array.isArray- sekarang didukung dengan baik dan bekerja di seluruh bingkai .

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 mundur Anda dapat menambahkan yang berikut ini

# 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 tidak perlu mendeteksi array yang dibuat dalam bingkai yang berbeda, Anda juga bisa menggunakannya instanceof

obj instanceof Array

Metode yang diberikan dalam standar ECMAScript untuk menemukan kelas Objek adalah dengan menggunakan toStringmetode dari Object.prototype.

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

Atau Anda dapat menggunakan typeofuntuk menguji apakah itu sebuah String:

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

Atau jika Anda tidak peduli dengan kinerja, Anda bisa melakukan concatke Array kosong yang baru.

someVar = [].concat( someVar );

Ada juga konstruktor yang dapat Anda query langsung:

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

Lihat pengobatan menyeluruh dari blog @TJ Crowder , seperti yang diposting di komentarnya di bawah ini.

Lihatlah patokan ini untuk mendapatkan ide metode mana yang berkinerja lebih baik: http://jsben.ch/#/QgYAV

Dari @Bharath convert string to array menggunakan Es6 untuk pertanyaan yang diajukan:

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

seharusnya:

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']

Pertama-tama saya akan memeriksa apakah implementasi Anda mendukung isArray:

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

Anda juga dapat mencoba menggunakan instanceofoperator

v instanceof Array

jQuery juga menawarkan $.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 didukung):

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

Bayangkan Anda memiliki array ini di bawah ini :

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

Javascript (browser baru dan lama):

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 panggil seperti ini:

isArray(arr);

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

Array.isArray(arr);

jQuery:

$.isArray(arr);

Sudut:

angular.isArray(arr);

Garis Bawah dan Lodash:

_.isArray(arr);

Array.isArray bekerja dengan cepat, tetapi tidak didukung oleh semua versi browser. Jadi Anda bisa membuat pengecualian untuk 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)
{
    return object.constructor === Array;
}

Seperti yang dikatakan MDN di sini :

gunakan Array.isArray atau Object.prototype.toString.call untuk membedakan objek biasa dari array

Seperti ini:

• Object.prototype.toString.call(arr) === '[object Array]', atau

• Array.isArray(arr)

Hanya ada satu solusi garis untuk pertanyaan ini

x instanceof Array

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

Anda bisa memeriksa tipe variabel Anda apakah array dengan;

var myArray=[];

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

Saya akan membuat fungsi untuk menguji jenis objek yang Anda hadapi ...

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 dapat menulis pernyataan sederhana jika ...

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

Saya melakukan ini dengan cara yang sangat sederhana. Bekerja untukku. Adakah kekurangannya?

Array.prototype.isArray = true;

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

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

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

Ini menghilangkan if / else, dan menjelaskan kemungkinan array menjadi null atau tidak terdefinisi

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 memperbarui biola jsperf dengan dua metode alternatif serta pengecekan kesalahan.

Ternyata metode yang mendefinisikan nilai konstan dalam prototipe 'Objek' dan 'Array' lebih cepat daripada metode lainnya. Ini adalah hasil yang agak mengejutkan.

/* 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 berfungsi jika variabel mengambil nilai yang tidak ditentukan, tetapi mereka berfungsi jika Anda yakin bahwa mereka memiliki nilai. Berkenaan dengan memeriksa dengan kinerja dalam pikiran jika suatu nilai adalah array atau nilai tunggal, metode kedua terlihat seperti metode cepat yang valid. Itu sedikit lebih cepat daripada 'instanceof' di Chrome, dua kali lebih cepat dari metode terbaik kedua di Internet Explorer, Opera dan Safari (di komputer saya).

Saya tahu, bahwa orang mencari semacam pendekatan javascript mentah. Tetapi jika Anda tidak ingin memikirkannya, silakan lihat di sini: http://underscorejs.org/#isArray

_.isArray(object) 

Mengembalikan nilai true jika objek adalah Array.

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

Solusi terbaik yang saya lihat adalah penggantian lintas-browser untuk typeof. Lihat solusi Angus Croll di sini .

Versi TL; DR ada di bawah ini, tetapi artikel ini adalah diskusi yang bagus tentang masalah ini sehingga Anda harus membacanya jika Anda punya 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 */};

Inilah pendekatan malas saya:

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

// ...

var test = [],
    wat = {};

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

Saya tahu itu penghinaan untuk "mengacaukan" prototipe, tetapi tampaknya berperforma lebih baik daripada toStringmetode yang direkomendasikan .

Catatan: Jebakan dari pendekatan ini adalah bahwa ia tidak akan bekerja melintasi iframebatas , tetapi untuk kasus penggunaan saya ini bukan masalah.

Ada contoh yang bagus dalam buku Pola Pola Stoyan Stefanov JavaScript yang seharusnya menangani semua masalah yang mungkin terjadi serta memanfaatkan metode ECMAScript 5 Array.isArray () .

Jadi begini:

if (typeof Array.isArray === "undefined") {
    Array.isArray = function (arg) {
        return Object.prototype.toString.call(arg) === "[object Array]";
    };
}

Omong-omong, jika Anda menggunakan jQuery, Anda dapat menggunakan metode itu $ .isArray ()

cara termudah dan tercepat untuk memeriksa apakah Obyek adalah Array atau tidak.

 var arr = [];
  arr.constructor.name ==='Array'  //return true;

atau

arr.constructor ===Array //return true;

atau Anda dapat membuat fungsi utilitas:

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

pemakaian:

isArray(arr); //return true

Berikut ini dapat digunakan jika Anda tahu bahwa objek Anda tidak memiliki metode concat.

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

Anda bisa adalah metode isArray tapi saya lebih suka memeriksanya

Object.getPrototypeOf(yourvariable) === Array.prototype

Jika hanya dua jenis nilai yang bisa diteruskan ke fungsi ini adalah string atau array string, tetap sederhana dan gunakan tanda typeofcentang untuk kemungkinan string:

function someFunc(arg) {
    var arr = (typeof arg == "string") ? [arg] : arg;
}

A = [1,2,3]
console.log(A.map==[].map)

Mencari versi terpendek di sini adalah apa yang saya dapatkan sejauh ini.

Catatan, tidak ada fungsi sempurna yang akan selalu mendeteksi semua kemungkinan kombinasi. Lebih baik mengetahui semua kemampuan dan keterbatasan alat Anda daripada mengharapkan alat ajaib.

function isArray(value) {
    if (value) {
        if (typeof value === 'object') {
            return (Object.prototype.toString.call(value) == '[object Array]')
        }
    }
    return false;
}

var ar = ["ff","tt"]
alert(isArray(ar))

Fungsi sederhana untuk menguji apakah nilai input adalah array adalah sebagai berikut:

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

Ini berfungsi lintas browser, dan dengan browser yang lebih lama. Ini ditarik dari posting blog TJ Crowders

Anda dapat mencoba ini:

var arr = []; (or) arr = new Array();
var obj = {}; (or) arr = new Object();

arr.constructor.prototype.hasOwnProperty('push') //true

obj.constructor.prototype.hasOwnProperty('push') // false

Fungsi ini akan mengubah hampir semua hal menjadi array:

function arr(x) {
    if(x === null || x === undefined) {
        return [];
    }
    if(Array.isArray(x)) {
        return x;
    }
    if(isString(x) || isNumber(x)) {
        return [x];
    }
    if(x[Symbol.iterator] !== undefined || x.length !== undefined) {
        return Array.from(x);
    }
    return [x];
}

function isString(x) {
    return Object.prototype.toString.call(x) === "[object String]"
}

function isNumber(x) {
    return Object.prototype.toString.call(x) === "[object Number]"
}

Ini menggunakan beberapa fitur browser yang lebih baru sehingga Anda mungkin ingin mengisi ini untuk dukungan maksimal.

Contoh:

> arr(null);
[]
> arr(undefined)
[]
> arr(3.14)
[ 3.14 ]
> arr(1/0)
[ Infinity ]
> gen = function*() { yield 1; yield 2; yield 3; }
[Function: gen]
> arr(gen())
[ 1, 2, 3 ]
> arr([4,5,6])
[ 4, 5, 6 ]
> arr("foo")
[ 'foo' ]

String NB akan dikonversi menjadi array dengan elemen tunggal, bukan array karakter. HapusisString centang jika Anda lebih suka sebaliknya.

Saya sudah menggunakan di Array.isArraysini karena ini yang paling kuat dan juga paling sederhana.

Dalam kasus Anda, Anda dapat menggunakan concatmetode Array yang dapat menerima objek tunggal serta array (dan bahkan digabungkan):

function myFunc(stringOrArray)
{
  var arr = [].concat(stringOrArray);

  console.log(arr);

  arr.forEach(function(item, i)
  {
    console.log(i, "=", item);
  })
}

myFunc("one string");

myFunc(["one string", "second", "third"]);

concat tampaknya menjadi salah satu metode tertua Array (bahkan IE 5.5 tahu dengan baik).