यह निर्धारित करने के लिए कि जावास्क्रिप्ट सरणी में किसी विशेषता के साथ कोई ऑब्जेक्ट है जो किसी दिए गए मान के बराबर है?

Question

मेरे पास एक सरणी है

vendors = [
    {
      Name: 'Magenic',
      ID: 'ABC'
     },
    {
      Name: 'Microsoft',
      ID: 'DEF'
    } //and so on goes array... 
];

मैगीनिक मौजूद है या नहीं, यह देखने के लिए मैं इस ऐरे की जाँच कैसे करूँ? जब तक मेरे पास नहीं है, मैं लूप नहीं करना चाहता। मैं संभावित रूप से कुछ हजार रिकॉर्ड के साथ काम कर रहा हूं।

---

UPDATED

चूँकि यह एक लोकप्रिय पोस्ट है, मैंने सोचा कि मैं कुछ नया पाया हूँ। और ऐसा लगता है कि @CAFxX पहले ही इसे साझा कर चुका है! मुझे इन्हें अधिक बार पढ़ना चाहिए। मुझे https://benfrain.com/understanding-native-javascript-array-methods/ आया ।

vendors.filter(function(vendor){ return vendor.Name === "Magenic" })

और ईसीएमएस्क्रिप्ट 2015 के साथ नए तीर फ़ंक्शन का उपयोग करना और भी सरल है:

vendors.filter(vendor => vendor.Name === "Magenic")

Comments

कृपया प्रतीत होता है यादृच्छिक टिप्पणी क्षमा करें, लेकिन क्या आपका सवाल JSON या सिर्फ जावास्क्रिप्ट सरणियों से जुड़ा है?

— एलेक्स टर्पिन

यदि आप चयनित समाधान को अपडेट करते हैं तो @CAFxX समाधान बेहतर है।

— eMarine

सहमत, कि पहले नहीं देखा था!

— डेविड लोज़ी

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

— पायोटर कुला

आप मानचित्र समारोह का उपयोग कर सकते हैं, बहुत उपयोगी

— मोनिर अलहुसिनी

Answer 1

2018 संपादित करें : यह उत्तर 2011 से है, इससे पहले कि ब्राउज़रों ने व्यापक रूप से सरणी फ़िल्टरिंग विधियों और तीर फ़ंक्शन का समर्थन किया था। CAFxX के उत्तर पर एक नज़र डालें ।

एक लूप के बिना किसी सरणी में किसी चीज़ की जांच करने का कोई "जादू" तरीका नहीं है। यहां तक ​​कि अगर आप कुछ फ़ंक्शन का उपयोग करते हैं, तो फ़ंक्शन स्वयं एक लूप का उपयोग करेगा। आप क्या कर सकते हैं जैसे ही आप लूप से बाहर निकलते हैं, आप पाते हैं कि आप कम्प्यूटेशनल समय को कम करने के लिए क्या देख रहे हैं।

var found = false;
for(var i = 0; i < vendors.length; i++) {
    if (vendors[i].Name == 'Magenic') {
        found = true;
        break;
    }
}

Comments

कोई दिक्कत नहीं है। ध्यान रखें कि कीथ का घोल भी बहुत व्यवहार्य है और आपको लूपिंग से बचाता है।

— एलेक्स टर्पिन

आपको एक झंडे की ज़रूरत नहीं है अगर आपको यह जानने की ज़रूरत है कि "कुछ" है या नहीं, तो आप सरणी के आकार के साथ स्कैन सूचकांक के मूल्य की जांच कर सकते हैं। इसके लिए काम करने के लिए सूचकांक संस्करण को निश्चित रूप से बयान के लिए पहले घोषित किया जाना चाहिए।

— एलेक्स

ये विकल्प अब काम करने लगते हैं:

— seller.forEach

JSON.stringify (विक्रेताओं) के बारे में क्या है ।indexOf ('Magenic')! == -1

— अंतिम सांस

@LastBreath जिसके परिणामस्वरूप 'Magenic'वस्तु में कहीं और एक गलत सकारात्मक परिणाम हो सकता है

— एलेक्स टर्पीन

Answer 2

को सुदृढ़ करने की आवश्यकता नहीं है पहियापाश, कम से कम स्पष्ट रूप से ( तीर के कार्यों का उपयोग करके , आधुनिक ब्राउज़र केवल ):

if (vendors.filter(e => e.Name === 'Magenic').length > 0) {
  /* vendors contains the element we're looking for */
}

या, अभी तक बेहतर :

if (vendors.some(e => e.Name === 'Magenic')) {
  /* vendors contains the element we're looking for */
}

संपादित करें: यदि आपको घटिया ब्राउज़रों के साथ संगतता की आवश्यकता है तो आपका सबसे अच्छा शर्त है:

if (vendors.filter(function(e) { return e.Name === 'Magenic'; }).length > 0) {
  /* vendors contains the element we're looking for */
}

Comments

@Rocket आपने मेरा उत्तर क्यों संपादित किया? घुंघराले ब्रेसिज़ के बिना वाक्य रचना पूरी तरह से मान्य जावास्क्रिप्ट है ।

— सीएएफएक्सएक्स

"लैम्ब्डा" सिंटैक्स अभी भी Chrome 16 (जो कि घटिया ब्राउज़र नहीं है) में काम नहीं करता है।

— रॉकेट हज़मत

यह आपकी घटिया परिभाषा पर निर्भर करता है, मुझे लगता है। यह वाक्य रचना 1.8 जावास्क्रिप्ट का हिस्सा है।

— CAFxX

पहले और दूसरे उदाहरण में आपके द्वारा उपयोग की जा रही अभिव्यक्ति बंद हो गई है, एक गैर-मानक है, उपयोग न करें! मोज़िला से चेतावनी (उस लिंक को देखें)। वे केवल कभी फ़ायरफ़ॉक्स में काम करते थे, और अब पदावनत हो गए हैं और तीर के कार्यों के पक्ष में हटा दिए जाएंगे ।

— doppelgreener 13

@ 7bault क्योंकि someएक वस्तु name === "Magenic"मिल जाने के बाद शॉर्ट सर्किट हो सकता है। इसके साथ filter, यह सरणी के अंत तक प्रत्येक आइटम की जांच करेगा और एक नई सरणी आइटम बनाएगा, जो स्थिति से मेल खाती है, फिरlength

— बजे adiga

Answer 3

कोई लूप आवश्यक नहीं है। तीन तरीके जो दिमाग में आते हैं:

Array.prototype.some ()

यह आपके प्रश्न का सबसे सटीक उत्तर है, अर्थात "जाँच करें कि क्या कुछ मौजूद है", एक बूल परिणाम का अर्थ है। यह सच होगा यदि कोई 'मैजेनिक' ऑब्जेक्ट हैं, अन्यथा गलत:

let hasMagenicVendor = vendors.some( vendor => vendor['Name'] === 'Magenic' )

Array.prototype.filter ()

यह सभी 'मैजेनिक' वस्तुओं की एक सरणी लौटाएगा, भले ही केवल एक ही हो (एक-तत्व सरणी वापस करेगा):

let magenicVendors = vendors.filter( vendor => vendor['Name'] === 'Magenic' )

यदि आप इसे एक बूलियन के साथ ज़बरदस्ती करने की कोशिश करते हैं, तो यह काम नहीं करेगा, क्योंकि खाली सरणी (कोई 'मैगनिक' ऑब्जेक्ट) अभी भी सत्य नहीं है। तो बस magenicVendors.lengthअपने सशर्त में उपयोग करें।

Array.prototype.find ()

यह पहला 'Magenic' ऑब्जेक्ट लौटाएगा (या undefinedयदि कोई नहीं है):

let magenicVendor = vendors.find( vendor => vendor['Name'] === 'Magenic' );

यह बूलियन ओके (कोई भी वस्तु सत्य है, undefinedझूठा है) के साथ मेल खाती है।

---

नोट: मैं विक्रेता के बजाय विक्रेता ["नाम"] का उपयोग कर रहा हूं। संपत्ति के नामों के अजीब आवरण के कारण।

नोट 2: नाम की जाँच करते समय सख्त समानता (===) के बजाय ढीली समानता (==) का उपयोग करने का कोई कारण नहीं।

Comments

यह इंगित करना उपयोगी है कि हुड के नीचे, ये सभी लूपिंग हैं। ये भी केवल लूपिंग और संचालन के लिए की तुलना में सभी कम्प्यूटेशनल हैं।

— thePartyTurtle

साथ ही उस प्यार को यहाँ साझा करें: stackoverflow.com/questions/21748670/… तो मेरे जैसे और भी लोग उस पुराने पेज पर नहीं जाते और धारणाएँ बनाते हैं।

— thePartyTurtle

Answer 4

स्वीकृत उत्तर अभी भी काम करता है लेकिन अब हमारे पास [Array.find][1]समान प्रभाव को प्राप्त करने के लिए एक ECMAScript 6 मूल विधि है।

एमडीएन का हवाला देते हुए:

खोज () विधि सरणी में पहले तत्व का मान लौटाती है जो प्रदान किए गए परीक्षण फ़ंक्शन को संतुष्ट करता है। अन्यथा अपरिभाषित वापस कर दिया जाता है।

var arr = []; 
var item = {
  id: '21',
  step: 'step2',
  label: 'Banana',
  price: '19$'
};

arr.push(item);
/* note : data is the actual object that matched search criteria 
  or undefined if nothing matched */
var data = arr.find( function( ele ) { 
    return ele.id === '21';
} );

if( data ) {
 console.log( 'found' );
 console.log(data); // This is entire object i.e. `item` not boolean
}

मेरी jsfiddle लिंक देखें आईज़ के लिए पॉलीफ़िल है जो मोज़िला द्वारा प्रदान किया गया है

Comments

छोटा हो सकता है अगर आप बस करते हैं return ele.id == '2', लेकिन एक अच्छा ES6 समाधान के लिए +1।

— लाइ फिश

ताजा जवाब देने के लिए अच्छा है :) बस सोच रहा था कि प्रदर्शन बेहतर है या ऊपर दिए गए जवाबों की तुलना में नहीं है ...

— Emidomenge

मुझे लगता है कि यह बताना महत्वपूर्ण है कि 'डेटा' का रिटर्न वैल्यू (जब ele.id एक आईडी से मेल खाता है, जैसे कि '21') स्वयं सरणी आइटम होने वाला है (इस मामले में, संपूर्ण आइटम ऑब्जेक्ट)। यदि उम्मीद की जा रही थी कि डेटा वैरिएबल रिजल्ट एक मिथ्या मूल्य के बजाय 'सही' या 'गलत' होगा, तो आप व्यर्थ ही निराश होंगे।

— adamgede

धन्यवाद! मेरा काम थोड़ा अलग था। ऐरे में वस्तु का सूचकांक प्राप्त करें => push if <0 || splice(index, 1)यहाँ मेरा अपडेट किया गया कोड है:const index = this.selected.indexOf(this.selected.find(s => s.id == passedObj.id))

— लियोनिद ज़ादोरोज़्निख

Answer 5

यहाँ मैं यह करूँगा तरीका है

const found = vendors.some(item => item.Name === 'Magenic');

array.some()विधि जाँचता है कि किसी मापदंड में कम से कम एक मान है जो मानदंड से मेल खाता है और बूलियन देता है। यहाँ से आप यहाँ जा सकते हैं:

if (found) {
// do something
} else {
// do something else
}

Answer 6

जब तक आप इसे इस तरह से पुनर्गठन नहीं करना चाहते:

vendors = {
    Magenic: {
      Name: 'Magenic',
      ID: 'ABC'
     },
    Microsoft: {
      Name: 'Microsoft',
      ID: 'DEF'
    } and so on... 
};

जो आप कर सकते हैं if(vendors.Magnetic)

आपको लूप करना पड़ेगा

Comments

मामले में वह अभी भी वस्तु संरचना को बनाए रखने के लिए इसे इस्तेमाल करना चाहता था, जहां

— कीथ.अबरामो

Answer 7

ECMAScript 6 विनिर्देश के अनुसार, आप उपयोग कर सकते हैं findIndex।

const magenicIndex = vendors.findIndex(vendor => vendor.Name === 'Magenic');

magenicIndexया तो पकड़ लेंगे 0(जो कि सरणी में सूचकांक है) या -1अगर यह नहीं मिला।

Comments

बस लोगों को जागरूक करने के लिए कि 0 अभी भी एक गलत परिणाम के रूप में मेल खाएगा यदि यह शर्त के रूप में इस्तेमाल किया गया था। इस कारण से मुझे लगता है कि आप अधिक तार्किक सत्य मूल्यांकन प्राप्त करने के लिए खोज () बेहतर है ।

— dhj

Answer 8

जैसा कि ओपी ने सवाल पूछा है कि क्या कुंजी मौजूद है या नहीं ।

एक अधिक सुरुचिपूर्ण समाधान जो ईएस 6 कम फ़ंक्शन का उपयोग करके बूलियन लौटाएगा

const magenicVendorExists =  vendors.reduce((accumulator, vendor) => (accumulator||vendor.Name === "Magenic"), false);

नोट: कम करने का प्रारंभिक पैरामीटर एक है falseऔर यदि सरणी में कुंजी है तो यह सही वापस आ जाएगी।

आशा है कि यह बेहतर और क्लीनर कोड के कार्यान्वयन में मदद करता है

Comments

कब से !! [] झूठ के बराबर है?

— सर्गेई

अच्छा पकड़ा। घट का उपयोग करके अद्यतन उत्तर :)

— जय चक्र

ये गलत है। पहला पैरामीटर reduceसंचायक है और vendorऑब्जेक्ट नहीं है । यह false.Name === "Magenic"हर लूप में जाँच करता है और यह झूठा लौट आता है

— adiga

@ आदि: सही।

— जय चक्र

कृपया मिर्जा लीका के समाधान की भी जाँच करें। एक बहुत अधिक सुरुचिपूर्ण समाधान।

— जय चक्र

Answer 9

आप वास्तव में वस्तु को देखे बिना नहीं रह सकते।

आपको शायद अपनी संरचना को थोड़ा बदलना चाहिए, जैसे

vendors = {
    Magenic:   'ABC',
    Microsoft: 'DEF'
};

तब आप इसे लुक-हैश की तरह इस्तेमाल कर सकते हैं।

vendors['Microsoft']; // 'DEF'
vendors['Apple']; // undefined

Answer 10

बहुत देर हो सकती है, लेकिन जावास्क्रिप्ट सरणी में दो तरीके someऔर everyविधि हैं जो एक बूलियन को लौटाता है और इसे प्राप्त करने में आपकी सहायता कर सकता है।

मुझे लगता है someकि आप जो हासिल करना चाहते हैं, उसके लिए सबसे उपयुक्त होगा।

vendors.some( vendor => vendor['Name'] !== 'Magenic' )

कुछ पुष्टि करते हैं कि सरणी में कोई भी वस्तु दी गई स्थिति को संतुष्ट करती है।

vendors.every( vendor => vendor['Name'] !== 'Magenic' )

प्रत्येक पुष्टि करता है कि सरणी की सभी वस्तुएँ दी गई स्थिति को संतुष्ट करती हैं।

Comments

यह काम नहीं करता है const array1 = [{name:'Mike'},{name:'Alice'}]; console.log(array1.every(item => item.name !== 'Mike'));यह सच लौटना चाहिए

— थानवा च।

क्षमा करें, मेरा मतलब है some, मेरे उत्तर को अपडेट करेगा।

— अकिंजीला टोनी 22

Answer 11

आपको लूप करना है, इसके आसपास कोई रास्ता नहीं है।

function seekVendor(vendors, name) {
  for (var i=0, l=vendors.length; i<l; i++) {
    if (typeof vendors[i] == "object" && vendors[i].Name === name) {
      return vendors[i];
    }
  }
}

बेशक आप इसे और अधिक मनभावन बनाने के लिए linq.js जैसी लाइब्रेरी का उपयोग कर सकते हैं :

Enumerable.From(vendors).Where("$.Name == 'Magenic'").First();

( एक डेमो के लिए jsFiddle देखें )

मुझे संदेह है कि linq.js एक सीधे-आगे लूप की तुलना में तेज़ होगा, लेकिन यह निश्चित रूप से अधिक लचीला है जब चीजें थोड़ी अधिक जटिल हो जाती हैं।

Answer 12

सरणी तत्वों के लिए परीक्षण:

JS ऑफर एरे फ़ंक्शन करता है जो आपको अपेक्षाकृत आसानी से प्राप्त करने की अनुमति देता है। वे निम्नलिखित हैं:

1. Array.prototype.filter: कॉलबैक फ़ंक्शन लेता है जो एक परीक्षण है, सरणी को कॉलबैक के साथ फिर से iterated किया जाता है और इस कॉलबैक के अनुसार फ़िल्टर किया जाता है। एक नया फ़िल्टर किया गया सरणी वापस आ गया है।
2. Array.prototype.some: एक कॉलबैक फ़ंक्शन लेता है जो एक परीक्षण है, फिर सरणी कॉलबैक के साथ पुनरावृत्त होती है और यदि कोई तत्व परीक्षण से गुजरता है, तो बूलियन सच वापस आ जाता है। अन्यथा असत्य वापस कर दिया जाता है

बारीकियों को एक उदाहरण के माध्यम से समझाया गया है:

उदाहरण:

vendors = [
    {
      Name: 'Magenic',
      ID: 'ABC'
     },
    {
      Name: 'Microsoft',
      ID: 'DEF'
    } //and so on goes array... 
];

// filter returns a new array, we instantly check if the length 
// is longer than zero of this newly created array
if (vendors.filter(company => company.Name === 'Magenic').length ) {
  console.log('I contain Magenic');
}

// some would be a better option then filter since it directly returns a boolean
if (vendors.some(company => company.Name === 'Magenic')) {
  console.log('I also contain Magenic');
}

ब्राउज़र समर्थन:

ये 2 फ़ंक्शन फ़ंक्शन हैं ES6, सभी ब्राउज़र उनका समर्थन नहीं कर सकते हैं। इसे दूर करने के लिए आप एक पॉलीफिल का उपयोग कर सकते हैं। यहाँ Array.prototype.some(एमडीएन से) के लिए पॉलीफ़िल है :

if (!Array.prototype.some) {
  Array.prototype.some = function(fun, thisArg) {
    'use strict';

    if (this == null) {
      throw new TypeError('Array.prototype.some called on null or undefined');
    }

    if (typeof fun !== 'function') {
      throw new TypeError();
    }

    var t = Object(this);
    var len = t.length >>> 0;

    for (var i = 0; i < len; i++) {
      if (i in t && fun.call(thisArg, t[i], i, t)) {
        return true;
      }
    }

    return false;
  };
}

Answer 13

यदि आप jquery का उपयोग कर रहे हैं, तो आप सभी मिलान वस्तुओं के साथ सरणी बनाने के लिए grep का लाभ ले सकते हैं:

var results = $.grep(vendors, function (e) {
    return e.Name == "Magenic";
});

और फिर परिणाम सरणी का उपयोग करें:

for (var i=0, l=results.length; i<l; i++) {
    console.log(results[i].ID);
}

Answer 14

मुझे सही करो अगर मैं गलत हूँ .. मैं forEachइस तरह से विधि का इस्तेमाल कर सकता था,

var found=false;
vendors.forEach(function(item){
   if(item.name === "name"){
       found=true;

   }
});

आजकल मैं इसका इस्तेमाल कर रहा हूं, क्योंकि यह सरलता और आत्म व्याख्यात्मक शब्द है। धन्यवाद।

Comments

नोट: यहां वापसी का कोई फायदा नहीं

— एडीसन

Answer 15

आप मेरे लिए इसका काम आजमा सकते हैं।

const _ = require('lodash');

var arr = [
  {
    name: 'Jack',
    id: 1
  },
  {
    name: 'Gabriel',
    id: 2
  },
  {
    name: 'John',
    id: 3
  }
]

function findValue(arr,value) {
  return _.filter(arr, function (object) {
    return object['name'].toLowerCase().indexOf(value.toLowerCase()) >= 0;
  });
}

console.log(findValue(arr,'jack'))
//[ { name: 'Jack', id: 1 } ]

Comments

वैसे यह एक बहुत पुराना सवाल है और मुझे लगता है कि इसका अद्यतन आजकल सबसे अच्छा समाधान है।

— फेडेरिको गेलफियोन

Answer 16

आप लिटाश का उपयोग कर सकते हैं । यदि आपके आवेदन के लिए लॉश लाइब्रेरी बहुत भारी है, तो अनावश्यक फ़ंक्शन का उपयोग नहीं करने पर विचार करें।

let newArray = filter(_this.props.ArrayOne, function(item) {
                    return find(_this.props.ArrayTwo, {"speciesId": item.speciesId});
                });

ऐसा करने का यह सिर्फ एक तरीका है। एक और एक हो सकता है:

var newArray=  [];
     _.filter(ArrayOne, function(item) {
                        return AllSpecies.forEach(function(cItem){
                            if (cItem.speciesId == item.speciesId){
                            newArray.push(item);
                          }
                        }) 
                    });

console.log(arr);

उपरोक्त उदाहरण भी बिना किसी पुस्तकालयों का उपयोग किए बिना फिर से लिखे जा सकते हैं:

var newArray=  [];
ArrayOne.filter(function(item) {
                return ArrayTwo.forEach(function(cItem){
                    if (cItem.speciesId == item.speciesId){
                    newArray.push(item);
                  }
                }) 
            });
console.log(arr);

आशा है कि मेरा उत्तर मदद करता है।

Answer 17

यहाँ कई उत्तर अच्छे और बहुत आसान हैं। लेकिन अगर आपके ऑब्जेक्ट की एक निश्चित सीमा है, तो आप नीचे दिए गए ट्रिक का उपयोग कर सकते हैं:

किसी ऑब्जेक्ट में सभी नाम को मैप करें।

vendors = [
    {
      Name: 'Magenic',
      ID: 'ABC'
     },
    {
      Name: 'Microsoft',
      ID: 'DEF'
    }
];

var dirtyObj = {}
for(var count=0;count<vendors.length;count++){
   dirtyObj[vendors[count].Name] = true //or assign which gives you true.
}

अब यह मैला ओब्ज आप बार-बार बिना किसी लूप के उपयोग कर सकते हैं।

if(dirtyObj[vendor.Name]){
  console.log("Hey! I am available.");
}

Answer 18

एक वस्तु को दूसरे से तुलना करने के लिए, मैं लूप में (वस्तुओं के माध्यम से लूप में प्रयुक्त) और कुछ के लिए संयोजन करता हूं। आपको किसी सीमा से बाहर जाने आदि के बारे में चिंता करने की ज़रूरत नहीं है, जिससे कुछ कोड की बचत होती है। .Some पर प्रलेखन यहाँ पाया जा सकता है

var productList = [{id: 'text3'}, {id: 'text2'}, {id: 'text4', product: 'Shampoo'}]; // Example of selected products
var theDatabaseList = [{id: 'text1'}, {id: 'text2'},{id: 'text3'},{id:'text4', product: 'shampoo'}];    
var  objectsFound = [];

for(let objectNumber in productList){
    var currentId = productList[objectNumber].id;   
    if (theDatabaseList.some(obj => obj.id === currentId)) {
        // Do what you need to do with the matching value here
        objectsFound.push(currentId);
    }
}
console.log(objectsFound);

एक वैकल्पिक तरीका है कि मैं एक वस्तु की दूसरे से तुलना करता हूं, ऑब्जेक्ट में ऑब्जेक्ट की राशि प्राप्त करने के लिए Object.keys () के साथ लूप के लिए नेस्टेड का उपयोग करना है। नीचे कोड:

var productList = [{id: 'text3'}, {id: 'text2'}, {id: 'text4', product: 'Shampoo'}]; // Example of selected products
var theDatabaseList = [{id: 'text1'}, {id: 'text2'},{id: 'text3'},{id:'text4', product: 'shampoo'}];    
var objectsFound = [];

for(var i = 0; i < Object.keys(productList).length; i++){
        for(var j = 0; j < Object.keys(theDatabaseList).length; j++){
        if(productList[i].id === theDatabaseList[j].id){
            objectsFound.push(productList[i].id);
        }       
    }
}
console.log(objectsFound);

अपने सटीक प्रश्न का उत्तर देने के लिए, यदि आप किसी ऑब्जेक्ट में एक मूल्य खोज रहे हैं, तो आप लूप के लिए एकल का उपयोग कर सकते हैं।

var vendors = [
    {
      Name: 'Magenic',
      ID: 'ABC'
     },
    {
      Name: 'Microsoft',
      ID: 'DEF'
    } 
];

for(var ojectNumbers in vendors){
    if(vendors[ojectNumbers].Name === 'Magenic'){
        console.log('object contains Magenic');
    }
}

Answer 19

वैकल्पिक रूप से आप यह कर सकते हैं:

const find = (key, needle) => return !!~vendors.findIndex(v => (v[key] === needle));

Comments

आप बेहतर कहेंगे कि वह ऐसा क्यों कर सकता है

— अज़ज़बी हयथेम

Answer 20

var without2 = (arr, args) => arr.filter(v => v.id !== args.id); उदाहरण:

without2([{id:1},{id:1},{id:2}],{id:2})

परिणाम: बिना 2 ([{आईडी: 1}, {आईडी: 1}, {आईडी: 2}], {आईडी: 2})

Comments

मुझे लगता है कि आपका कहना है कि परिणाम: [{आईडी: 1}, {आईडी: 1}]

— इसहाक पाक

Answer 21

const a = [{one:2},{two:2},{two:4}]
const b = a.filter(val => "two" in val).length;
if (b) {
   ...
}

Comments

कृपया और कुछ विवरण और सुनिश्चित करें कि आपके द्वारा प्रदान किए गए उदाहरण .. (फ़िल्टर मूल सरणी को नहीं बदलेगा लेकिन क्लोन करेगा)।

— मोशे सिमंतोव

Answer 22

इस समस्या को हल करने के लिए मेरा दृष्टिकोण ES6 का उपयोग करना और एक फ़ंक्शन बनाना है जो हमारे लिए चेक करता है। इस फ़ंक्शन का लाभ यह है कि आपके प्रोजेक्ट के माध्यम से पुन: प्रयोज्य किया जा सकता है कि किसी भी दिए गए ऑब्जेक्ट की सरणी की जाँच करें keyऔर valueचेक करें।

एनओएलजीएच तालक, कोडे को देखता है

सरणी

const ceos = [
  {
    name: "Jeff Bezos",
    company: "Amazon"
  }, 
  {
    name: "Mark Zuckerberg",
    company: "Facebook"
  }, 
  {
    name: "Tim Cook",
    company: "Apple"
  }
];

समारोह

const arrayIncludesInObj = (arr, key, valueToCheck) => {
  let found = false;

  arr.some(value => {
    if (value[key] === valueToCheck) {
      found = true;
      return true; // this will break the loop once found
    }
  });

  return found;
}

कॉल / प्रयोग

const found = arrayIncludesInObj(ceos, "name", "Tim Cook"); // true

const found = arrayIncludesInObj(ceos, "name", "Tim Bezos"); // false

Answer 23

मैं बल्कि regex के साथ जाना होगा।

यदि आपका कोड इस प्रकार है,

vendors = [
    {
      Name: 'Magenic',
      ID: 'ABC'
     },
    {
      Name: 'Microsoft',
      ID: 'DEF'
    }
];

मैं सलाह दूँगा

/"Name":"Magenic"/.test(JSON.stringify(vendors))

Comments

कुछ लोग, जब एक समस्या का सामना करते हैं, तो सोचते हैं "मुझे पता है, मैं नियमित अभिव्यक्ति का उपयोग करूंगा।" अब उन्हें दो समस्याएं हैं।

— क्रेसरजैक

इसके तहत फाइल करें, सिर्फ इसलिए कि आप कुछ कर सकते हैं, इसका मतलब यह नहीं है कि आपको चाहिए।

— लियाम