कोई आइटम जावास्क्रिप्ट सरणी में है या नहीं, यह जानने का सबसे अच्छा तरीका है?

Question

कोई वस्तु किसी सरणी में है या नहीं, यह जानने का सबसे अच्छा तरीका क्या है?

यह सबसे अच्छा तरीका है मुझे पता है:

function include(arr, obj) { 
    for(var i=0; i<arr.length; i++) { 
     if (arr[i] == obj) return true; 
    } 
} 

include([1,2,3,4], 3); // true 
include([1,2,3,4], 6); // undefined 

Answer 1

function include(arr,obj) { 
    return (arr.indexOf(obj) != -1); 
} 

संपादित करें: यह हालांकि IE6, 7 या 8 पर काम नहीं करेगा।

1. Mozilla's (ECMA-262) संस्करण:

   if (!Array.prototype.indexOf) 
       { 
   
        Array.prototype.indexOf = function(searchElement /*, fromIndex */) 
   
       { 
   
   
       "use strict"; 
   
       if (this === void 0 || this === null) 
        throw new TypeError(); 
   
       var t = Object(this); 
       var len = t.length >>> 0; 
       if (len === 0) 
        return -1; 
   
       var n = 0; 
       if (arguments.length > 0) 
       { 
        n = Number(arguments[1]); 
        if (n !== n) 
        n = 0; 
        else if (n !== 0 && n !== (1/0) && n !== -(1/0)) 
        n = (n > 0 || -1) * Math.floor(Math.abs(n)); 
       } 
   
       if (n >= len) 
        return -1; 
   
       var k = n >= 0 
         ? n 
         : Math.max(len - Math.abs(n), 0); 
   
       for (; k < len; k++) 
       { 
        if (k in t && t[k] === searchElement) 
        return k; 
       } 
       return -1; 
       }; 
   
   } 
   

2. Daniel James के संस्करण:

   if (!Array.prototype.indexOf) { 
       Array.prototype.indexOf = function (obj, fromIndex) { 
       if (fromIndex == null) { 
        fromIndex = 0; 
       } else if (fromIndex < 0) { 
        fromIndex = Math.max(0, this.length + fromIndex); 
       } 
       for (var i = fromIndex, j = this.length; i < j; i++) { 
        if (this[i] === obj) 
         return i; 
       } 
       return -1; 
       }; 
   } 
   

3. roosteronacid सबसे अच्छा समाधान का अगर यह नहीं मौजूद है यह अपने को परिभाषित करने के लिए है का संस्करण:

   Array.prototype.hasObject = (
       !Array.indexOf ? function (o) 
       { 
       var l = this.length + 1; 
       while (l -= 1) 
       { 
        if (this[l - 1] === o) 
        { 
         return true; 
        } 
       } 
       return false; 
       } : function (o) 
       { 
       return (this.indexOf(o) !== -1); 
       } 
   ); 
   

Answer 2

यदि सरणी निरस्त नहीं है, तो वास्तव में एक बेहतर तरीका नहीं है (ऊपर उल्लिखित इंडेक्स का उपयोग करने के अलावा, जो मुझे लगता है कि एक ही चीज़ के बराबर है)। यदि सरणी सॉर्ट की जाती है, तो आप इस तरह काम करते हैं:

1. सरणी के मध्य तत्व को चुनें।
2. क्या वह तत्व है जिसे आप चुना तत्व से बड़ा है? यदि ऐसा है, तो आप सरणी के निचले हिस्से को समाप्त कर दिया है। यदि ऐसा नहीं है, तो आप शीर्ष आधे को समाप्त कर दिया है।
3. सरणी के शेष भाग के मध्य तत्व को चुनें, और चरण 2 में जारी रखें, शेष सरणी के हिस्सों को समाप्त करें। आखिरकार आप या तो अपना तत्व पाएंगे या देखने के लिए कोई सरणी नहीं छोड़ी जाएगी।

बाइनरी खोज सरणी की लंबाई के लॉगेरिथम के आनुपातिक समय में चलती है, इसलिए यह प्रत्येक व्यक्तिगत तत्व को देखने से कहीं अधिक तेज हो सकती है।

Answer 3

यहां आपके लिए कुछ मेटा-ज्ञान है - अगर आप को पता है कि आप किसी सरणी के साथ क्या कर सकते हैं, प्रलेखन जाँच - यहाँ मोज़िला

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

वहाँ आप संदर्भ देखेंगे के लिए सरणी पेज है सूचकांक के लिए, जावास्क्रिप्ट 1.6

Answer 4

में जोड़ा गया यह आपके उद्देश्य पर निर्भर करता है। आप वेब के लिए कार्यक्रम हैं, तो indexOf से बचने के लिए, यह इंटरनेट एक्सप्लोरर     6 (! उनमें से बहुत कुछ अभी भी प्रयोग किया जाता) द्वारा समर्थित नहीं है, या सशर्त उपयोग करें:

if (yourArray.indexOf !== undefined) result = yourArray.indexOf(target); 
else result = customSlowerSearch(yourArray, target); 

indexOf शायद मूल कोड में कोडित है, तो यह जावास्क्रिप्ट में आप जो कुछ भी कर सकते हैं उससे तेज है (यदि सरणी उपयुक्त है तो बाइनरी सर्च/डिकोटॉमी को छोड़कर)। नोट: यह स्वाद का सवाल है, लेकिन मैं अपनी दिनचर्या के अंत में एक return false; करना होगा, एक सच्चे बूलियन वापस जाने के लिए ...

Answer 5

पहले, ब्राउज़रों कि पहले से ही नहीं है यह है के लिए जावास्क्रिप्ट में indexOf लागू ।उदाहरण के लिए, Erik Arvidsson's array extras देखें (भी, associated blog post)। और फिर आप ब्राउज़र समर्थन के बारे में चिंता किए बिना indexOf का उपयोग कर सकते हैं।

if (!Array.prototype.indexOf) { 
    Array.prototype.indexOf = function (obj, fromIndex) { 
     if (fromIndex == null) { 
      fromIndex = 0; 
     } else if (fromIndex < 0) { 
      fromIndex = Math.max(0, this.length + fromIndex); 
     } 
     for (var i = fromIndex, j = this.length; i < j; i++) { 
      if (this[i] === obj) 
       return i; 
     } 
     return -1; 
    }; 
} 

यह लंबाई स्टोर करने के लिए इतना है कि यह यह हर यात्रा को देखने के लिए की जरूरत नहीं है बदल गया है: यहाँ अपने indexOf कार्यान्वयन के एक से थोड़ा अनुकूलित संस्करण है। लेकिन अंतर बड़ा नहीं है। एक कम सामान्य प्रयोजन समारोह तेजी से हो सकता है:

var include = Array.prototype.indexOf ? 
    function(arr, obj) { return arr.indexOf(obj) !== -1; } : 
    function(arr, obj) { 
     for(var i = -1, j = arr.length; ++i < j;) 
      if(arr[i] === obj) return true; 
     return false; 
    }; 

मैं मानक समारोह का उपयोग करना पसंद है और जब यह वास्तव में आवश्यक है के लिए सूक्ष्म अनुकूलन की इस तरह हो जाता है। लेकिन यदि आप माइक्रो-ऑप्टिमाइज़ेशन पर उत्सुक हैं तो मैंने benchmarks को अनुकूलित किया है जो टिप्पणियों में जुड़े रोस्टरोनोनैसिड को benchmark searching in arrays पर अनुकूलित करता है। हालांकि वे बहुत कच्चे हैं, एक पूर्ण जांच विभिन्न प्रकारों, अलग-अलग लंबाई और विभिन्न स्थानों पर होने वाली वस्तुओं को खोजने के साथ सरणी का परीक्षण करेगी।

Answer 6

आप jQuery उपयोग कर रहे हैं:

$.inArray(5 + 5, [ "8", "9", "10", 10 + "" ]); 

अधिक जानकारी के लिए:

यहाँ दो हैं: यदि एक वस्तु जावास्क्रिप्ट में एक सरणी है यहाँ विस्तृत है http://api.jquery.com/jQuery.inArray/

Answer 7

एक मजबूत तरीका जाँच करने के लिए xa.js ढांचे से कार्य जो मैं utils = {} 'कंटेनर' से संलग्न करता हूं। इन्हें आपको सरणी का पता लगाने में मदद करनी चाहिए।

/** 
* Adding hasOwnProperty method if needed. 
*/ 
if (typeof Object.prototype.hasOwnProperty !== 'function') { 
    Object.prototype.hasOwnProperty = function (prop) { 
     var type = utils.type(this); 
     type = type.charAt(0).toUpperCase() + type.substr(1); 
     return this[prop] !== undefined 
      && this[prop] !== window[type].prototype[prop]; 
    }; 
} 

और अंत में इस in_array समारोह:

function in_array (needle, haystack, strict) { 
    var key; 

    if (strict) { 
     for (key in haystack) { 
      if (!haystack.hasOwnProperty[key]) continue; 

      if (haystack[key] === needle) { 
       return true; 
      } 
     } 
    } else { 
     for (key in haystack) { 
      if (!haystack.hasOwnProperty[key]) continue; 

      if (haystack[key] == needle) { 
       return true; 
      } 
     } 
    } 

    return false; 
} 

Answer 8

.indexOf() संभालने

var utils = {}; 

/** 
* utils.isArray 
* 
* Best guess if object is an array. 
*/ 
utils.isArray = function(obj) { 
    // do an instanceof check first 
    if (obj instanceof Array) { 
     return true; 
    } 
    // then check for obvious falses 
    if (typeof obj !== 'object') { 
     return false; 
    } 
    if (utils.type(obj) === 'array') { 
     return true; 
    } 
    return false; 
}; 

/** 
* utils.type 
* 
* Attempt to ascertain actual object type. 
*/ 
utils.type = function(obj) { 
    if (obj === null || typeof obj === 'undefined') { 
     return String (obj); 
    } 
    return Object.prototype.toString.call(obj) 
     .replace(/\[object ([a-zA-Z]+)\]/, '$1').toLowerCase(); 
}; 

आप तो यदि एक वस्तु एक सरणी में है की जांच करना चाहते हैं, तो मैं भी इस कोड को शामिल किया जाएगा लागू किया गया है

Object.defineProperty(Array.prototype,'has', 
{ 
    value:function(o, flag){ 
    if (flag === undefined) { 
     return this.indexOf(o) !== -1; 
    } else { // only for raw js object 
     for(var v in this) { 
      if(JSON.stringify(this[v]) === JSON.stringify(o)) return true; 
     } 
     return false;      
    }, 
    // writable:false, 
    // enumerable:false 
}) 

!!! Array.prototype.has=function(){... मत बनाओ क्योंकि आप प्रत्येक सरणी में एक संख्यात्मक तत्व जोड़ देंगे और जेएस टूटा हुआ है।

//use like   
[22 ,'a', {prop:'x'}].has(12) // false 
["a","b"].has("a") // true 

[1,{a:1}].has({a:1},1) // true 
[1,{a:1}].has({a:1}) // false 

संदर्भ की बजाय मूल्य से 2 आर्ग (झंडा) बलों comparation के उपयोग