एक वस्तु सरणी में indexOf विधि?

Question

किसी सरणी के सूचकांक को प्राप्त करने के लिए सबसे अच्छी विधि क्या है जिसमें वस्तुएँ होती हैं?

इस परिदृश्य की कल्पना करें:

var hello = {
    hello: 'world',
    foo: 'bar'
};
var qaz = {
    hello: 'stevie',
    foo: 'baz'
}

var myArray = [];
myArray.push(hello,qaz);

अब मैं चाहूंगा कि indexOfवह वस्तु जो helloसंपत्ति है 'stevie', जो इस उदाहरण में है 1।

मैं जावास्क्रिप्ट के साथ बहुत नौसिखिया हूं और मुझे नहीं पता कि क्या कोई सरल तरीका है या अगर मुझे ऐसा करने के लिए अपना स्वयं का फ़ंक्शन बनाना चाहिए।

Comments

क्या आप दो वस्तुओं का विलय करना चाहते हैं helloऔर qaz?

— आर्मिन

नहीं, मैं नहीं। मैं एक सरणी में वस्तुओं की एक सूची रखना चाहता हूं।

— एंटोनियो लगुना

आह ठीक है! आप सरणी में पूरे ऑब्जेक्ट की स्थिति जानना चाहते हैं, जिसमें एक परिभाषित संपत्ति है।

— आर्मिन

मुझे इस एसओ उत्तर के साथ इस सटीक समस्या को हल करने के लिए एक बहुत ही सरल कार्य मिला: var elementPos = array.map(function(x) {return x.id; }).indexOf(idYourAreLookingFor); var objectFound = array[elementPos]; [लिंक] ( stackoverflow.com/a/16100446/1937255 )

— रिक

ES6 Array.indexOf स्वीकृत उत्तर से बेहतर है (यदि ES6 आपके लिए काम करता है) - नीचे पूर्ण उदाहरण देखें

— yar1

Answer 1

मुझे लगता है कि आप मानचित्र फ़ंक्शन का उपयोग करके इसे एक पंक्ति में हल कर सकते हैं :

pos = myArray.map(function(e) { return e.hello; }).indexOf('stevie');

Comments

यह ईमानदारी से स्वीकृत उत्तर होना चाहिए। आजकल अधिकांश ब्राउज़र समर्थन करते हैंArray.prototype.map()

— अल्बर्टबेंगल

यह IE8 द्वारा समर्थित नहीं है, लेकिन अगर यह कोई समस्या नहीं है, तो यह सबसे अच्छा समाधान है।

— एंटोनियो लागुना

उम ... यह ध्यान देने योग्य नहीं है कि Array.prototype.map () मैप की गई वस्तुओं से युक्त एक नया सरणी बनाता है? तो, यदि आपको 1000 तत्वों के साथ एक सरणी मिली है, तो आपने पहले 1000 तत्वों के साथ एक और सरणी बनाई है , तो इसे खोजें? यह सार्थक होगा कि मुझे लगता है कि इस विधि का प्रदर्शन बनाम लूप के लिए सरल है। खासकर जब आप सीमित संसाधनों वाले मोबाइल प्लेटफॉर्म पर चल रहे हों।

— डग

@Doug यद्यपि प्रदर्शन के बारे में आपकी बात वास्तव में सही है, जो अपने दाहिने दिमाग में कोड की एक पंक्ति को सात के साथ एक आवेदन के लिए बदल देंगे जो कि परिभाषा IO / Network द्वारा लगभग बाध्य है जब तक कि वे बाधाओं के लिए तैयार नहीं होंगे?

— जेरेड स्मिथ

तकनीकी तौर पर एक मिनिमाइज्ड js फाइल भी एक लाइन है; D

— अधिक से अधिक

Answer 2

Array.prototype.findIndex IE (नॉन-एज) के अलावा सभी ब्राउज़रों में समर्थित है। लेकिन प्रदान की गई पॉलीफिल अच्छी है।

var indexOfStevie = myArray.findIndex(i => i.hello === "stevie");

नक्शे के साथ समाधान ठीक है। लेकिन आप हर खोज पर संपूर्ण सरणी पर पुनरावृत्ति कर रहे हैं। यह केवल खोज के लिए सबसे खराब मामला है और जो एक मैच देखने के बाद पुनरावृत्ति को रोकता है।

---

वास्तव में एक संक्षिप्त तरीका नहीं है (जब देवों को IE8 के बारे में चिंता करनी थी) , लेकिन यहां एक सामान्य समाधान है:

var searchTerm = "stevie",
    index = -1;
for(var i = 0, len = myArray.length; i < len; i++) {
    if (myArray[i].hello === searchTerm) {
        index = i;
        break;
    }
}

या एक समारोह के रूप में:

function arrayObjectIndexOf(myArray, searchTerm, property) {
    for(var i = 0, len = myArray.length; i < len; i++) {
        if (myArray[i][property] === searchTerm) return i;
    }
    return -1;
}
arrayObjectIndexOf(arr, "stevie", "hello"); // 1

बस कुछ नोट:

1. सरणियों पर छोरों में ... के लिए उपयोग न करें
2. एक बार जब आप अपनी "सुई" पा लेते हैं, तो लूप को तोड़ना या फंक्शन से बाहर लौटना सुनिश्चित करें
3. वस्तु समानता से सावधान रहें

उदाहरण के लिए,

var a = {obj: 0};
var b = [a];
b.indexOf({obj: 0}); // -1 not found

Comments

फंक्शन में सर्चटरम तुलना गलत है क्योंकि यह सर्च होना चाहिए :)

— एंटोनियो लागुना

कई घटनाएं हुईं

— जो

@SteveBennett यह एक प्रदर्शन अनुकूलित संस्करण है; सरणी की लंबाई केवल एक बार निर्धारित की जानी है (जब फॉर-लूप के लिए चर आरंभ किए जाते हैं)। आपके मामले में, लंबाई को हर पुनरावृत्ति नए सिरे से जांचा जाता है। यह भी देखें stackoverflow.com/questions/5349425/… और stackoverflow.com/questions/8452317/… हालाँकि, अगर प्रदर्शन उच्च बेशुमार नहीं है तो यह वास्तव में मायने नहीं रखता है।

— 15

अच्छा जवाब है, लेकिन मैंने कुछ प्रदर्शन बेंचमार्किंग किया (देखें jsperf.com/find-index-of-object-in-array-by-contents ), और पाया कि यहाँ वर्णित फ़ंक्शन आधारित दूसरा सबसे अच्छा उत्तर देने वाला उत्तर प्रतीत होता है। मेरे उत्तर में उल्लिखित एक कार्य के बजाय केवल अधिक कार्य करने वाला समाप्त होता है, इसे एक प्रोटोटाइप में डाल दिया जाता है ।

— यूनिपोनिक

Answer 3

ES2015 में, यह बहुत आसान है:

myArray.map(x => x.hello).indexOf('stevie')

या, संभवतः बड़े सरणियों के लिए बेहतर प्रदर्शन के साथ:

myArray.findIndex(x => x.hello === 'stevie')

Comments

अच्छा दृष्टिकोण ES6 उपयोग करने के लिए

— kag

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

— २००:

यह जानना अच्छा है, यदि प्रदर्शन कार्य के लिए महत्वपूर्ण है। यह बहुत कम ही होता है, मेरे अनुभव में है, लेकिन ymmv।

— स्टीव बेनेट

Answer 4

var idx = myArray.reduce( function( cur, val, index ){

    if( val.hello === "stevie" && cur === -1 ) {
        return index;
    }
    return cur;

}, -1 );

Answer 5

मुझे पाब्लो का जवाब पसंद है, लेकिन Array # indexOf और Array # मैप सभी ब्राउज़रों पर काम नहीं करता है। यदि यह उपलब्ध है, तो अंडरस्कोर देशी कोड का उपयोग करेगा, लेकिन इसमें कमियां भी हैं। साथ ही इसमें पाब्लो की अनाम मानचित्र विधि के ठीक वैसा ही करने की प्लक विधि है।

var idx = _.chain(myArray).pluck("hello").indexOf("Stevie").value();

Comments

Array.prototyp.map () IE9 + के लिए बंद किया गया है और आप IE8, 7, 6 के लिए पॉलीफ़िल का उपयोग कर सकते हैं: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference;

— जोहान ईचावरिया

आप एक पॉलीफ़िल का उपयोग कर सकते हैं। । । या आप केवल अंडरस्कोर या लॉश का उपयोग कर सकते हैं, जो मूल रूप से पॉलीफिल हैं जो कि अन्य अच्छाइयों का एक पूरा गुच्छा है । अंडरस्कोर से क्या आपत्ति है? आकार?

— tandrewnichols 11

मुझे वास्तव में अंडरस्कोर पसंद है, आपका उत्तर भी बहुत चालाक है, लेकिन IMHO पाब्लो का जवाब सबसे साफ है।

— जोहान ईचावरिया

वाह, मैंने कभी इस तरह से शाइनिंग का उपयोग करने के लिए नहीं सोचा था। मुझे वास्तव में पसंद है कि यह कैसे खोज को धाराप्रवाह बनाता है।

— डायलन पियर्स

chainयहाँ बहुत ही शानदार है। _.pluck(myArray, 'hello').indexOf('stevie')

— स्टीव बेनेट

Answer 6

या इसे प्रोटोटाइप:

Array.prototype.indexOfObject = function arrayObjectIndexOf(property, value) {
    for (var i = 0, len = this.length; i < len; i++) {
        if (this[i][property] === value) return i;
    }
    return -1;
}

myArr.indexOfObject("name", "stevie");

Comments

बहुत ही सुविधाजनक! हालाँकि मैं प्रोटोटाइप का चुनाव करूंगा। IndexOfObject ताकि एक्सिसिटिव Array.indexOf पद्धति में हस्तक्षेप न किया जा सके। Array.prototype.indexOfObject = function(property, value) { for (var i = 0, len = this.length; i < len; i++) { if (this[i][property] === value) return i; } return -1; };

— एडम

मैं इसे पहले से स्टोर किए जा रहे पुराने के साथ एक सेल्फ एक्जीक्यूशन क्लोजर में लपेटूंगा, जिसमें रिप्लेसमेंट फंक्शन की पहली लाइन कुछ लाइनों के साथ होगी if (typeof property === 'string' || typeof property === 'number' || typeof property === 'boolean') return oldIndexOf(property, value);। ऐसा इसलिए है क्योंकि ये कुछ प्रकार हैं जो अपरिवर्तनीय हैं। यदि आवश्यक हो तो मैं मूल विधि में वापसी को सक्षम करने के लिए एक तीसरा तर्क भी पेश करूंगा।

— इसियाह मीडोज

Answer 7

संक्षिप्त करें

myArray.indexOf('stevie','hello')

बक्सों का इस्तेमाल करें :

  /*****NORMAL****/  
[2,4,5].indexOf(4) ;//OUTPUT 1
 /****COMPLEX*****/
 [{slm:2},{slm:4},{slm:5}].indexOf(4,'slm');//OUTPUT 1
 //OR
 [{slm:2},{slm:4},{slm:5}].indexOf(4,function(e,i){
   return e.slm;
});//OUTPUT 1
/***MORE Complex**/
[{slm:{salat:2}},{slm:{salat:4}},{slm:{salat:5}}].indexOf(4,function(e,i){
   return e.slm.salat;
});//OUTPUT 1

एपीआई:

    Array.prototype.indexOfOld=Array.prototype.indexOf

    Array.prototype.indexOf=function(e,fn){
      if(!fn){return this.indexOfOld(e)}
      else{ 
       if(typeof fn ==='string'){var att=fn;fn=function(e){return e[att];}}
        return this.map(fn).indexOfOld(e);
      }
    };

Answer 8

मैंने यहां विभिन्न उत्तरों का कुछ प्रदर्शन परीक्षण किया, जिन्हें कोई भी स्वयं चला सकता है:

https://jsperf.com/find-index-of-object-in-array-by-contents

क्रोम में मेरे प्रारंभिक परीक्षणों के आधार पर, निम्नलिखित विधि (एक प्रोटोटाइप के अंदर स्थापित लूप के लिए उपयोग करना) सबसे तेज़ है:

Array.prototype.indexOfObject = function (property, value) {
    for (var i = 0, len = this.length; i < len; i++) {
        if (this[i][property] === value) return i;
    }
    return -1;
}

myArray.indexOfObject("hello", "stevie");

यह कोड नाथन ज़ेटा के उत्तर का थोड़ा संशोधित संस्करण है।

प्रदर्शन बेंचमार्क में मैंने इसे दोनों लक्ष्य के साथ मध्य (इंडेक्स 500) और बहुत अंत (इंडेक्स 999) में 1000 ऑब्जेक्ट एरे में रखने की कोशिश की, और भले ही मैंने लक्ष्य को सरणी में बहुत अंतिम आइटम के रूप में रखा (अर्थ इससे पहले कि यह मिला है) यह सरणी में हर एक आइटम के माध्यम से लूप है) यह अभी भी सबसे तेजी से समाप्त होता है।

इस समाधान को बार-बार निष्पादित करने के लिए सबसे अधिक में से एक होने का लाभ भी है, क्योंकि केवल अंतिम पंक्ति को दोहराया जाना चाहिए:

myArray.indexOfObject("hello", "stevie");

Comments

मैं बस अपने परीक्षणों के साथ एक बेला का उपयोग करके इस प्रश्न का उत्तर पोस्ट करने वाला था, लेकिन आपके उत्तर के लिए धन्यवाद, मुझे अब और नहीं चाहिए। मैं सिर्फ आपके परीक्षणों की पुष्टि करना चाहता हूं - मुझे एक ही परिणाम मिला, लेकिन एक के whileबजाय एक लूप का उपयोग करना for, और performance.now()। मैं चाहता हूं कि यह उत्तर और अधिक सामने आए और मैंने इसे पहले देखा था, इससे मुझे कुछ समय बचा होगा ...

— यिन कॉगनीटो

Answer 9

मैंने कई तरीकों की तुलना की और इस समस्या को हल करने के सबसे तेज़ तरीके के साथ एक परिणाम प्राप्त किया। यह एक forपाश है। यह किसी भी अन्य विधि की तुलना में 5+ गुना तेज है।

यहाँ परीक्षण का पृष्ठ है: https://jsbench.me/9hjewv6a98

Comments

एक for-ofलूप नहीं गुम ?

— डगलस गास्केल

Answer 10

जबकि, यहां अधिकांश अन्य उत्तर मान्य हैं। कभी-कभी, जहां आप इसका उपयोग करेंगे, उसके पास केवल एक छोटा सा सरल कार्य करना सबसे अच्छा है।

// indexOf wrapper for the list of objects
function indexOfbyKey(obj_list, key, value) {
    for (index in obj_list) {
        if (obj_list[index][key] === value) return index;
    }
    return -1;
}
// Find the string in the list (default -1)
var test1 = indexOfbyKey(object_list, 'name', 'Stevie');
var test2 = indexOfbyKey(object_list, 'last_name', 'some other name');

यह इस बात पर निर्भर करता है कि आपके लिए क्या महत्वपूर्ण है। यह कोड की लाइनों को बचा सकता है और एक-लाइनर का उपयोग करने के लिए बहुत चालाक हो सकता है, या कहीं एक जेनेरिक समाधान डाल सकता है जो विभिन्न किनारे मामलों को कवर करता है। लेकिन कभी-कभी केवल यह कहना बेहतर होता है: "यहां मैंने ऐसा किया था" भविष्य के डेवलपर्स को छोड़ने के बजाय अतिरिक्त रिवर्स इंजीनियरिंग काम करना होगा। खासकर यदि आप अपने प्रश्न में अपने आप को "एक नौसिखिया" मानते हैं।

Answer 11

array.filter(function(item, indx, arr){ return(item.hello === 'stevie'); })[0];

मन [0]।

इसका उत्तर के reduceरूप में उपयोग करना उचित है Antonio Laguna।

माफी के लिए माफी ...

Answer 12

यदि आपकी ऑब्जेक्ट उसी के ऑब्जेक्ट है जिसे आप एरे के भीतर उपयोग कर रहे हैं, तो आपको ऑब्जेक्ट के इंडेक्स को उसी तरह प्राप्त करने में सक्षम होना चाहिए जैसे आप एक स्ट्रिंग करते थे।

var hello = {
    hello: 'world',
    foo: 'bar'
};
var qaz = {
    hello: 'stevie',
    foo: 'baz'
}

var qazCLONE = { // new object instance and same structure
    hello: 'stevie',
    foo: 'baz'
}

var myArray = [hello,qaz];

myArray.indexOf(qaz) // should return 1
myArray.indexOf(qazCLONE) // should return -1

Comments

यह वह उत्तर है जिसकी मैं तलाश कर रहा था क्योंकि यह मेरे लिए स्पष्ट नहीं था कि क्या IndexOf मूल्य से मेल खाता है या क्या। अब मुझे पता है कि मैं अपनी वस्तु को खोजने के लिए IndexOf का उपयोग कर सकता हूं, और चिंता न करें यदि समान गुण वाले अन्य ऑब्जेक्ट हैं।

— एमडीवे

Answer 13

इसे इस्तेमाल करे:

console.log(Object.keys({foo:"_0_", bar:"_1_"}).indexOf("bar"));

https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/keys

Answer 14

सरल:

myArray.indexOf(myArray.filter(function(item) {
    return item.hello == "stevie"
})[0])

Answer 15

यदि आप केवल स्थिति को देखने में रुचि रखते हैं तो @ पाब्लो का उत्तर देखें ।

pos = myArray.map(function(e) { return e.hello; }).indexOf('stevie');

हालांकि, यदि आप तत्व को खोजने के लिए उत्सुक हैं (यानी यदि आप ऐसा कुछ करने की सोच रहे थे myArray[pos]), तो इसे करने के लिए एक और अधिक कुशल एक-लाइन तरीका है, उपयोग करना filter।

element = myArray.filter((e) => e.hello === 'stevie')[0];

पूर्णता परिणाम देखें (~ + 42% ऑप्स / सेकंड): http://jsbench.github.io/#7fa01f89a5dc5cc3bee79abfde80cdb3

Answer 16

इस उदाहरण को देखें: http://jsfiddle.net/89C54/

for (i = 0; i < myArray.length; i++) {
    if (myArray[i].hello === 'stevie') {
        alert('position: ' + i);
        return;
    }
}

यह शून्य से गिनना शुरू करता है।

Answer 17

मैंने किसी भी वस्तु के लिए नीचे दिए गए कोड और कार्यों को जांचने के लिए एक सामान्य कार्य किया है

function indexOfExt(list, item) {
    var len = list.length;

    for (var i = 0; i < len; i++) {
        var keys = Object.keys(list[i]);
        var flg = true;
        for (var j = 0; j < keys.length; j++) {
            var value = list[i][keys[j]];
            if (item[keys[j]] !== value) {
                flg = false;
            }
        }
        if (flg == true) {
            return i;
        }
    }
    return -1;
}

var items = [{ "hello": 'world', "foo": 'bar' }];
var selectedItem = { "hello": 'world', "foo": 'bar' };
alert(items.indexOf(selectedItem));
alert(indexOfExt(items, selectedItem));

पहला अलर्ट -1 (मतलब मैच नहीं मिला) और दूसरा अलर्ट 0 (मतलब मैच मिला) वापस आएगा।

Answer 18

अंडरस्कोर_.findIndex । जेएस लाइब्रेरी से उपयोग करें

यहाँ उदाहरण है _.findIndex([{a:1},{a: 2,c:10},{a: 3}], {a:2,c:10}) //1

Comments

यदि अतिरिक्त पुस्तकालयों से तरीकों का सुझाव दे तो आपको यह उल्लेख करना चाहिए कि वे कहाँ से आते हैं।

— Craicerjack

@Steve बेनेट अच्छा उपयोग। पुस्तकालय में अब अपनी जगह पर

— zabusa

Answer 19

ईएस 6 findIndexविधि का उपयोग करना , बिना लॉश या किसी अन्य पुस्तकालयों के बिना, आप लिख सकते हैं:

function deepIndexOf(arr, obj) {
  return arr.findIndex(function (cur) {
    return Object.keys(obj).every(function (key) {
      return obj[key] === cur[key];
    });
  });
}

यह वस्तु के तात्कालिक गुणों की तुलना करेगा, लेकिन गुणों में पुनरावृत्ति नहीं करेगा।

यदि आपका कार्यान्वयन findIndexअभी तक प्रदान नहीं करता है (सबसे अधिक नहीं), तो आप एक प्रकाश पॉलीफ़िल जोड़ सकते हैं जो इस खोज का समर्थन करता है:

function deepIndexOf(arr, obj) {
  function findIndex = Array.prototype.findIndex || function (pred) {
    for (let i = 0; i < this.length; ++i) {
      if (pred.call(this, this[i], i)) {
        return i;
      }
    }

    return -1;
  }

  return findIndex.call(arr, function (cur) {
    return Object.keys(obj).every(function (key) {
      return obj[key] === cur[key];
    });
  });
}

( इस डूप पर मेरे जवाब से )

Answer 20

आप मूल और सुविधाजनक फ़ंक्शन का Array.prototype.findIndex()मूल रूप से उपयोग कर सकते हैं :

FindIndex () विधि सरणी में एक सूचकांक देता है, यदि सरणी में कोई तत्व प्रदान किए गए परीक्षण फ़ंक्शन को संतुष्ट करता है। अन्यथा -1 वापस कर दिया जाता है।

बस एक नोट यह इंटरनेट एक्सप्लोरर, ओपेरा और सफारी पर समर्थित नहीं है, लेकिन आप नीचे दिए गए लिंक में दिए गए पॉलीफ़िल का उपयोग कर सकते हैं।

अधिक जानकारी:

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

var hello = {
  hello: 'world',
  foo: 'bar'
};
var qaz = {
  hello: 'stevie',
  foo: 'baz'
}

var myArray = [];
myArray.push(hello, qaz);

var index = myArray.findIndex(function(element, index, array) {
  if (element.hello === 'stevie') {
    return true;
  }
});
alert('stevie is at index: ' + index);

Answer 21

की Furthor @Monika गर्ग जवाब है, तो आप उपयोग कर सकते हैं findIndex()(वहाँ एक है polyfill unsupprted ब्राउज़र के लिए)।

मैंने देखा कि लोगों ने इस उत्तर को अस्वीकार कर दिया, और मुझे आशा है कि उन्होंने गलत वाक्य रचना के कारण ऐसा किया, क्योंकि मेरी राय में, यह सबसे सुंदर तरीका है।

FindIndex () विधि सरणी में एक सूचकांक देता है, यदि सरणी में कोई तत्व प्रदान किए गए परीक्षण फ़ंक्शन को संतुष्ट करता है। अन्यथा -1 वापस कर दिया जाता है।

उदाहरण के लिए:

var hello = {
  hello: 'world',
  foo: 'bar'
};
var qaz = {
  hello: 'stevie',
  foo: 'baz'
}

var myArray = [];
myArray.push(hello,qaz);

var index = myArray.findIndex(function(element) {
  return element.hello == 'stevie';
});

alert(index);

Comments

विधि सुरुचिपूर्ण लगती है, लेकिन एमडीएन के अनुसार कोई आईई समर्थन नहीं करता है? developer.mozilla.org/en/docs/Web/JavaScript/Reference/…

— जाको करहु

पॉलीफिल (उत्तर में लिंक) का उपयोग करने का प्रयास करें।

— मॉस फेउ

Answer 22

यह एरे में ऑब्जेक्ट के इंडेक्स को खोजने का तरीका है

    var myArray = [{  hello: 'world',
        foo: 'bar'
    },{
        hello: 'stevie',
        foo: 'baz'
    }];



    for (i = 0; i < myArray.length; i++) {
        if (myArray[i].hello === 'stevie') {
            alert('position: ' + i);
            return;
        }
    }

Answer 23

यह कस्टम कोड के बिना काम करता है

var arr, a, found;
arr = [{x: 1, y: 2}];
a = {x: 1, y: 2};
found = JSON.stringify(arr).indexOf(JSON.stringify(a)) > - 1;
// found === true

नोट: यह वास्तविक सूचकांक नहीं देता है, यह केवल यह बताता है कि आपकी वस्तु वर्तमान डेटा संरचना में मौजूद है या नहीं

Comments

यह मान्य नहीं है क्योंकि यह किसी भी सूचकांक को प्राप्त करने की अनुमति नहीं देता है

— एंटोनियो लगुना

Answer 24

आप बस उपयोग कर सकते हैं

const someId = 2;
const array = [{id:1}, {id:2}, {id:3}];
const index = array.reduce((i, item, index) => item.id === someId ? index : i, -1);
alert('someId ' + someId + ' is at index ' + index);

कोई अंडरस्कोर, नहीं के लिए, बस एक कम।

Answer 25

var hello = {hello: "world",  foo: "bar"};
var qaz = {hello: "stevie", foo: "baz"};
var myArray = [];
myArray.push(hello,qaz);

function indexOfObject( arr, key, value   ) {
    var j = -1;
    var result = arr.some(function(obj, i) { 
        j++;
        return obj[key] == value;
    })

    if (!result) {
        return -1;
    } else {
        return j;
    };
}

alert(indexOfObject(myArray,"hello","world"));

Comments

कुछ विधि का उपयोग करें।

— user3235365

Answer 26

आप ऐसा करने के लिए अपना स्वयं का प्रोटोटाइप बना सकते हैं:

कुछ इस तरह:

Array.prototype.indexOfObject = function (object) {
    for (var i = 0; i < this.length; i++) {
        if (JSON.stringify(this[i]) === JSON.stringify(object))
            return i;
    }
}

Comments

खराब अभ्यास, ब्रेकिंग इनकैप्सुलेशन: डेवलपर.

— mozilla.org/en-US/docs/Web/JavaScript/Guide/…

यह भी पुनरावर्ती रूप से परिभाषित वस्तुओं पर टूट जाएगा।

— जोसेफ कोको

Answer 27

मैं findIndex()विधि का उपयोग करना पसंद करूंगा :

 var index = myArray.findIndex('hello','stevie');

index आपको इंडेक्स नंबर देगा।

Comments

उत्तर, वर्तनी और कोड इंडेंटेशन और :) गलत हैं?

— सचिन वर्मा

findIndex किसी भी जावास्क्रिप्ट मानक कार्यान्वयन में नहीं है। ऐसी विधि के लिए आगामी (एक्मा 6) प्रस्ताव है, लेकिन इसका हस्ताक्षर ऐसा नहीं है। कृपया, स्पष्ट करें कि आपका क्या मतलब है (हो सकता है कि विधि का नाम), FindIndex विधि की घोषणा करें या आपके द्वारा उपयोग की जा रही लाइब्रेरी का नाम दें।

— सेबस्टियन एफ।