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

Bir işlev yazmaya çalışıyorum ve bu işlev ya bir dize listesi ya da tek bir dize kabul etsin istiyorum. Eğer bir dizeyse, bunu sadece tek bir öğe içeren bir diziye dönüştürmek istiyorum, böylece üzerinde dönerken hata alma korkusu olmadan bunu kullanabilirim.

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

Cevap #1

ECMAScript standardında Object sınıfını bulmak için verilen yöntem, Object.prototype üzerindeki toString yöntemini kullanmaktır.

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

Veya typeof kullanarak bunun bir string olup olmadığını test edebilirsiniz:

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

Veya performans konusunda endişelenmiyorsanız, yeni boş bir diziye concat yapabilirsiniz.

someVar = [].concat(someVar);

Ayrıca doğrudan sorgulayabileceğiniz yapıcı (constructor) da vardır:

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

Aşağıdaki yorumunda yayınladığı gibi, T.J. Crowder'ın blogundan kapsamlı bir incelemeye göz atın.

Hangi yöntemin daha iyi performans gösterdiğini anlamak için bu kıyaslamaya göz atın: http://jsben.ch/#/QgYAV

@Bharath'tan, sorulan soruya uygun olarak bir dizgeyi ES6 kullanarak diziye dönüştür:

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

Varsayalım ki:

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

Cevap #2

Modern tarayıcılarda şunu yapabilirsiniz:

Array.isArray(obj)

(Chrome 5, Firefox 4.0, Internet Explorer 9, Opera 10.5 ve Safari 5 tarafından desteklenmektedir)

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

Eğer jQuery kullanıyorsanız jQuery.isArray(obj) veya $.isArray(obj) kullanabilirsiniz. Eğer Underscore.js kullanıyorsanız _.isArray(obj) kullanabilirsiniz.

Farklı çerçevelerde oluşturulan dizileri algılamanız gerekmiyorsa, sadece instanceof kullanabilirsiniz:

obj instanceof Array

Cevap #3

Öncelikle uygulamanızın isArray'i destekleyip desteklemediğini kontrol ederdim:

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

Ayrıca instanceof operatörünü kullanmayı da deneyebilirsiniz

v instanceof Array

Cevap #4

jQuery ayrıca bir $.isArray() yöntemi 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>

Cevap #5

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

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

Cevap #6

Aşağıdaki dizinizin olduğunu hayal edin:

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

O zaman onu şöyle çağır:

isArray(arr);

JavaScript (Internet Explorer 9+, Chrome 5+, Firefox 4+, Safari 5+ ve Opera 10.5+)

Array.isArray(arr);

jQuery :

$.isArray(arr);

Angular :

angular.isArray(arr);

Underscore.js ve Lodash:

_.isArray(arr);

Cevap #7

Array.isArray hızlı çalışır, ancak tüm tarayıcı sürümleri tarafından desteklenmez.

Yani başkaları için bir istisna yapabilir ve evrensel bir yöntem kullanabilirsiniz:

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

Cevap #8

Bunu kontrol etmek için basit bir fonksiyon:

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

Cevap #9

Array.isArray() kullanabilirsiniz. İşte bir polyfill:

if (Array.isArray == null) {
  Array.isArray = (arr) => Object.prototype.toString.call(arr) === "[object Array]"
}

Cevap #10

MDN burada şöyle diyor:

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

Böyle:

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

  • Array.isArray(arr)

Cevap #11

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

x instanceof Array

x değişkeni ise, x bir dizi ise doğru döndürecek ve değilse yanlış döndürecektir.

Cevap #12

İlgilendiğiniz nesnenin türünü test etmek için bir fonksiyon 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

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

Cevap #13

Değişkeninizin bir dizi olup olmadığını şu şekilde kontrol edebilirsiniz;

var myArray=[];

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

Cevap #14

Bunu çok basit bir şekilde yapıyorum. Benim için işe yarıyor.

Array.prototype.isArray = true;

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

Cevap #15

Yorumları dikkate alarak bu cevabı geliştirme girişimim:

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

Bu, if/else kullanımından kurtulmayı sağlar ve dizinin null veya tanımsız olma olasılığını hesaba katar

Cevap #16

En iyi uygulama, bunu constructor kullanarak karşılaştırmaktır, şöyle bir şey

if(some_variable.constructor === Array){
  // do something
}

Ayrıca typeOf gibi diğer yöntemleri de kullanabilirsiniz, onu bir string'e dönüştürüp sonra karşılaştırabilirsiniz, ancak onu dataType ile karşılaştırmak her zaman daha iyi bir yaklaşımdır.

Cevap #17

Hata kontrolü ile birlikte iki alternatif yöntem ekleyerek jsperf batakçığını güncelledim.

Görünüşe göre, 'Object' ve 'Array' prototiplerinde sabit bir değer tanımlayan yöntem, diğer tüm yöntemlerden daha hızlıdır. Bu, 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/>");

Bu iki yöntem, değişken tanımsız bir değere sahipse işe yaramaz, ancak bir değere sahip olduklarından eminseniz işe yarar. Bir değerin dizi mi yoksa tek bir değer mi olduğunu performans açısından kontrol etmeye gelince, ikinci yöntem geçerli ve hızlı bir yöntem gibi görünüyor. Chrome'da 'instanceof' ile karşılaştırıldığında biraz daha hızlı, Internet Explorer, Opera ve Safari'de ikinci en iyi yöntemden iki kat daha hızlıdır (benim bilgisayarımda).

Cevap #18

Biliyorum, insanlar bir tür saf JavaScript yaklaşımı arıyor. Ama eğer bunun üzerine daha az düşünmek istiyorsanız, Underscore.js'in isArray'ine bir göz atın:

_.isArray(object)

Eğer object bir Dizi ise doğru döner.

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

İlgili makaleler