Bir nesnenin dizi olup olmadığını nasıl kontrol edebilirim?

Dizelerin listesini veya tek bir dizeyi kabul eden bir işlev yazmaya çalışıyorum. Bir dize ise, o zaman sadece bir öğe ile bir diziye dönüştürmek istiyorum, bu yüzden bir hata korkusu olmadan üzerinde döngü olabilir.

Peki, değişkenin bir dizi olup olmadığını nasıl kontrol ederim?

Aşağıdaki çeşitli çözümleri tamamladım ve bir jsperf testi oluşturdum . Hepsi hızlı, bu yüzden sadece kullanın Array.isArray- şimdi iyi destekleniyor ve çerçevelerde çalışıyor .

Modern tarayıcılarda şunları yapabilirsiniz:

Array.isArray(obj)

( Tarafından desteklenen Chrome 5, Firefox 4.0, IE 9, Opera 10.5 ve Safari 5)

Geriye dönük uyumluluk için aşağıdakileri ekleyebilirsiniz

# 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]';
  }
};

JQuery kullanıyorsanız jQuery.isArray(obj)veya kullanabilirsiniz $.isArray(obj). Alt çizgi kullanırsanız,_.isArray(obj)

Farklı karelerde oluşturulan dizileri algılamanız gerekmiyorsa, yalnızca instanceof

obj instanceof Array

ECMAScript standardında verilen Object sınıfını bulmak için kullanılan toStringmetodu kullanmaktır Object.prototype.

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

Veya typeofbunun bir String olup olmadığını test etmek için kullanabilirsiniz :

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

Veya performansla ilgili endişeleriniz yoksa concat, yeni bir boş Dizi için bir işlem yapabilirsiniz .

someVar = [].concat( someVar );

Doğrudan sorgulayabileceğiniz kurucu da var:

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

Bir göz atın kapsamlı tedavi dan @TJ Crowder'ın aşağıda onun yorumunda yayınlanmıştır olarak, blog.

Hangi yöntemin daha iyi performans gösterdiğine dair bir fikir edinmek için bu karşılaştırmaya göz atın : http://jsben.ch/#/QgYAV

Gönderen @Bharath soru sorulduğunda için ES6 kullanarak diziye dönüştürme dizesi:

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

varsayalım:

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

İlk olarak uygulamanızın destekleyip desteklemediğini kontrol ederim isArray:

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

instanceofOperatörü kullanmayı da deneyebilirsiniz

v instanceof Array

jQuery ayrıca bir $.isArray()yöntem sunar :

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>

Bu, tüm yöntemler arasında en hızlı olanıdır (tüm tarayıcılar desteklenir):

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

Aşağıda bu diziye sahip olduğunuzu düşünün :

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

Javascript (yeni ve eski tarayıcılar):

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

veya

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

veya

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

sonra şöyle deyin:

isArray(arr);

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

Array.isArray(arr);

jQuery:

$.isArray(arr);

Açısal:

angular.isArray(arr);

Alt Çizgi ve Lodash:

_.isArray(arr);

Array.isArray hızlı çalışır, ancak tüm tarayıcı sürümleri tarafından desteklenmez. Böylece başkaları için bir istisna yapabilir ve evrensel yöntemi kullanabilirsiniz:

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

Bunu kontrol etmek için basit işlev:

function isArray(object)
{
    return object.constructor === Array;
}

MDN'nin burada söylediği gibi :

normal nesneleri dizilerden ayırmak için Array.isArray veya Object.prototype.toString.call kullanın

Bunun gibi:

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

• Array.isArray(arr)

Bu soru için sadece bir satır çözüm var

x instanceof Array

burada x değişkendir, x bir dizi ise true, değilse false döndürür.

Değişkeninizin türünü bir dizi olup olmadığını kontrol edebilirsiniz;

var myArray=[];

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

Karşılaştığınız nesnenin türünü test etmek için bir işlev yapardım ...

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

o zaman basit bir if ifadesi yazabilirsiniz ...

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

Bunu çok basit bir şekilde yapıyorum. Benim için çalışıyor. Herhangi bir dezavantajı var mı?

Array.prototype.isArray = true;

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

Bu, yorumları dikkate alarak bu cevabı geliştirmeye çalışıyorum :

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

İf / else komutundan kurtulur ve dizinin boş veya tanımsız olma olasılığını açıklar

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

Hata kontrolü gibi iki alternatif yöntemle jsperf keman güncelledik .

'Nesne' ve 'Dizi' prototiplerinde sabit bir değer tanımlayan yöntemin diğer yöntemlerden daha hızlı olduğu ortaya çıkıyor. Biraz şaşırtıcı bir sonuçtur.

/* 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/>");

Değişken tanımsız değeri alıyorsa bu iki yöntem işe yaramaz, ancak bir değere sahip olduğundan eminseniz işe yarar. Bir değerin bir dizi mi yoksa tek bir değer mi olduğunu göz önünde bulundurarak performansı kontrol etmekle ilgili olarak, ikinci yöntem geçerli bir hızlı yöntem gibi görünür. Chrome'daki 'instanceof' den biraz daha hızlı, Internet Explorer, Opera ve Safari'de (makinemde) en iyi ikinci yöntemden iki kat daha hızlı.

İnsanların bir çeşit çiğ javascript yaklaşımı aradıklarını biliyorum. Ancak daha az düşünmek istiyorsanız, buraya bir göz atın: http://underscorejs.org/#isArray

_.isArray(object) 

Nesne bir Dizi ise true değerini döndürür.

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

Gördüğüm en iyi çözüm, typeof için çapraz tarayıcı değiştirme. Angus Croll'un çözümünü buradan kontrol edin .

TL; DR sürümü aşağıdadır, ancak makale konuyla ilgili harika bir tartışmadır, bu nedenle zamanınız varsa okumalısınız.

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

İşte tembel yaklaşımım:

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

// ...

var test = [],
    wat = {};

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

Ben prototip "karışıklık" için kutsal olduğunu biliyorum, ama önerilen toStringyöntemden önemli ölçüde daha iyi performans gibi görünüyor .

Not: Bu yaklaşımın bir dezavantajı, sınırlar arasında çalışmayacaktıriframe , ancak kullanım durumum için bu bir sorun değildir.

Stoyan Stefanov'un ECMAScript 5 yöntemi Array.isArray () yöntemini kullanmanın yanı sıra olası tüm sorunları ele alması gereken JavaScript Kalıpları kitabında güzel bir örnek var .

İşte burada:

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

Bu arada, jQuery kullanıyorsanız, bu yöntemi $ .isArray () kullanabilirsiniz

bir Nesnenin Dizi olup olmadığını kontrol etmenin en kolay ve en hızlı yolu.

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

veya

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

veya bir yardımcı program işlevi yapabilirsiniz:

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

kullanımı:

isArray(arr); //return true

Nesnenizin bir concat yöntemi olmadığını biliyorsanız, aşağıdakiler kullanılabilir.

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

Eğer isArray yöntemi olabilir ama ben ile kontrol etmeyi tercih ederim

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

Bu işleve iletilebilecek yalnızca iki tür değer bir dize veya bir dize dizisiyse, basit tutun typeofve dize olasılığı için bir denetim kullanın :

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

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

En kısa versiyonu bulmak için burada şimdiye kadar aldım.

Unutmayın, her zaman olası tüm kombinasyonları algılayacak mükemmel bir fonksiyon yoktur. Aletlerinizin tüm yeteneklerini ve sınırlarını bilmek sihirli bir araç beklemekten daha iyidir.

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))

Bir giriş değerinin bir dizi olup olmadığını sınamak için basit bir işlev şudur:

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

Bu çapraz tarayıcı ve eski tarayıcılarda çalışır. Bu TJ Crowders'ın blog yazısından alınmıştır

Bunu deneyebilirsiniz:

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

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

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

Bu işlev neredeyse her şeyi bir diziye dönüştürür:

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]"
}

Bazı yeni tarayıcı özelliklerini kullanır, böylece maksimum destek için bunu çoklu doldurmak isteyebilirsiniz.

Örnekler:

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

NB dizeleri, bir dizi karakter yerine tek bir öğeye sahip bir diziye dönüştürülecektir. SilisString tercih edip etmeyeceğinizi .

Array.isArrayBurada kullandım çünkü en sağlam ve aynı zamanda en basit olanı.

Sizin durumunuzda , dizi (ve hatta birleştirilmiş) kadar tek nesneleri de kabul edebilen Arrayconcat yöntemini kullanabilirsiniz :

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 Array'ın en eski yöntemlerinden biri gibi görünüyor (hatta IE 5.5 bunu iyi biliyor).