javascript - जांचें कि ऑब्जेक्ट एक सरणी है या नहीं?




arrays (20)

मैं एक ऐसा फ़ंक्शन लिखने की कोशिश कर रहा हूं जो या तो तारों की सूची स्वीकार करता है, या एक स्ट्रिंग। यदि यह एक स्ट्रिंग है, तो मैं इसे केवल एक आइटम के साथ सरणी में परिवर्तित करना चाहता हूं। फिर मैं किसी त्रुटि के डर के बिना इसे लूप कर सकता हूं।

तो मैं कैसे जांचूं कि चर एक सरणी है या नहीं?

मैंने नीचे दिए गए विभिन्न समाधानों को गोल किया है और एक जेएसपीआरएफ परीक्षण बनाया है।


Array.isArray तेजी से काम करता है, लेकिन यह ब्राउज़र के सभी संस्करणों द्वारा समर्थित नहीं है। तो आप दूसरों के लिए अपवाद बना सकते हैं और सार्वभौमिक विधि का उपयोग कर सकते हैं:

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

Stoyan Stefanov की पुस्तक जावास्क्रिप्ट पैटर्न में एक अच्छा उदाहरण है जो सभी संभावित समस्याओं को संभालने के साथ-साथ ECMAScript 5 विधि Array.isArray () का उपयोग करने का अनुमान लगाता है

तो यहां यह है:

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

वैसे, यदि आप jQuery का उपयोग कर रहे हैं, तो आप इसकी विधि $.isArray() का उपयोग कर सकते हैं


आधुनिक ब्राउज़रों में आप कर सकते हैं

Array.isArray(obj)

(क्रोम 5, फ़ायरफ़ॉक्स 4.0, आईई 9, ओपेरा 10.5 और सफारी द्वारा समर्थित 5)

पिछड़े संगतता के लिए आप निम्नलिखित जोड़ सकते हैं

# 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 का उपयोग करते हैं तो आप jQuery.isArray(obj) या $.isArray(obj) उपयोग कर सकते हैं। यदि आप अंडरस्कोर का उपयोग करते हैं तो आप _.isArray(obj) उपयोग कर सकते हैं

यदि आपको अलग-अलग फ्रेम में बनाए गए सरणी का पता लगाने की आवश्यकता नहीं है तो आप केवल instanceof उपयोग कर सकते हैं

obj instanceof Array

आप अपने चर के प्रकार की जांच कर सकते हैं चाहे वह एक सरणी है;

var myArray=[];

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

आप इस दृष्टिकोण को आजमा सकते हैं: http://web.archive.org/web/20100424091244/http://www.ajaxdr.com/code/javascript-version-of-phps-is_array-function/

संपादित करें : अगर आप पहले से ही अपने प्रोजेक्ट में JQuery का उपयोग कर रहे हैं, तो आप इसके फ़ंक्शन $.isArray() उपयोग कर सकते हैं।


आप इसे आजमा सकते हैं:

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

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

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

इसे जांचने के लिए सरल कार्य:

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

एक इनपुट मान एक सरणी है तो परीक्षण के लिए एक सरल कार्य निम्न है:

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

यह क्रॉस ब्राउज़र और पुराने ब्राउज़र के साथ काम करता है। इसे टीजे क्रॉडर ब्लॉग पोस्ट से खींचा जाता है


ऑब्जेक्ट की कक्षा को खोजने के लिए Object.prototype मानक में दी गई विधि ऑब्जेक्ट.प्रोटोटाइप से toString विधि का उपयोग करना है।

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

या यदि आप स्ट्रिंग है तो आप परीक्षण के लिए typeof का उपयोग कर सकते हैं:

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

या यदि आप प्रदर्शन के बारे में चिंतित नहीं हैं, तो आप बस एक नए खाली ऐरे के लिए एक concat कर सकते हैं।

someVar = [].concat( someVar );

ऐसे निर्माता भी हैं जिन्हें आप सीधे पूछ सकते हैं:

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

@ टीजे क्रॉउडर के ब्लॉग से एक संपूर्ण उपचार देखें , जैसा कि नीचे दी गई टिप्पणी में पोस्ट किया गया है।

यह तरीका प्राप्त करने के लिए यह jsben.ch/#/QgYAV देखें कि कौन सी विधि बेहतर प्रदर्शन करती है: jsben.ch/#/QgYAV

पूछे जाने वाले प्रश्न के लिए एएस 6 का उपयोग करके @भारत स्ट्रिंग से सरणी में कनवर्ट करें:

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

मान लीजिए:

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

कल्पना करें कि आपके पास नीचे यह सरणी है:

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

जावास्क्रिप्ट (नए और पुराने ब्राउज़र):

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

या

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

या

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

फिर इसे इस तरह कहते हैं:

isArray(arr);

जावास्क्रिप्ट (आईई 9 +, सी 5 +, एफएफ 4 +, सफ 5 +, ओपेरा 10.5 +)

Array.isArray(arr);

jQuery:

$.isArray(arr);

कोणीय:

angular.isArray(arr);

अंडरस्कोर और लोडाश:

_.isArray(arr);

टिप्पणियों को ध्यान में रखते हुए इस उत्तर पर सुधार करने का मेरा प्रयास है:

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

यह if / else से छुटकारा पाता है, और सरणी को शून्य या अपरिभाषित होने की संभावना के लिए खाते हैं


मुझे पता है, कि लोग किसी प्रकार के कच्चे जावास्क्रिप्ट दृष्टिकोण की तलाश में हैं। लेकिन अगर आप कम सोचना चाहते हैं, तो यहां एक नज़र डालें: http://underscorejs.org/#isArray

_.isArray(object) 

ऑब्जेक्ट एक ऐरे है तो सत्य वापस आता है।

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

मैं उस ऑब्जेक्ट के प्रकार का परीक्षण करने के लिए एक फ़ंक्शन करूंगा जिसके साथ आप काम कर रहे हैं ...

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

तो आप कथन अगर एक सरल लिख सकते हैं ...

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

मैं पहले जांच करता isArray कि आपका कार्यान्वयन समर्थन करता है isArray :

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

आप instanceof ऑपरेटर का उपयोग करने का भी प्रयास कर सकते हैं

v instanceof Array

मैंने देखा है कि सबसे अच्छा समाधान टाइप के लिए एक क्रॉस ब्राउज़र प्रतिस्थापन है। here एंगस क्रॉल का समाधान देखें।

टीएल; डीआर संस्करण नीचे है, लेकिन लेख इस मुद्दे की एक बड़ी चर्चा है, इसलिए यदि आपके पास समय है तो आपको इसे पढ़ना चाहिए।

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

यदि आप जानते हैं कि आपके ऑब्जेक्ट में एक कॉन्सटैट विधि नहीं है तो निम्नलिखित का उपयोग किया जा सकता है।

var arr = [];
if (typeof arr.concat === 'function') {
    console.log("It's an 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]"
}

यह कुछ नई ब्राउज़र सुविधाओं का उपयोग करता है ताकि आप इसे अधिकतम समर्थन के लिए पॉलीफिल करना चाहें।

उदाहरण:

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

एनबी तारों को सरणी की सरणी के बजाय एक तत्व के साथ एक सरणी में परिवर्तित किया जाएगा। isString चेक हटाएं यदि आप इसे दूसरी तरफ पसंद करेंगे।

मैंने Array.isArray का उपयोग यहां किया है क्योंकि यह सबसे मजबूत और सरलतम है।


यह सभी विधियों में सबसे तेज़ है (सभी ब्राउज़र समर्थित):

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

Array.isArray

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

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

यहां तक ​​कि सबसे कम संस्करण की खोज में मुझे अब तक क्या मिला है।

नोट, कोई सही कार्य नहीं है जो हमेशा सभी संभावित संयोजनों का पता लगाएगा। एक जादू उपकरण की अपेक्षा से अपने उपकरणों की सभी क्षमताओं और सीमाओं को जानना बेहतर है।








arrays