यदि संग्रह में कोई वस्तु है, तो यह जानने के लिए कि मैं लॉश में शामिल विधि का उपयोग कैसे करूं?

Question

लॉश मुझे बुनियादी डेटा प्रकारों की सदस्यता के लिए जाँच करने देता है includes:

_.includes([1, 2, 3], 2)
> true

लेकिन निम्नलिखित काम नहीं करता है:

_.includes([{"a": 1}, {"b": 2}], {"b": 2})
> false

यह मुझे भ्रमित करता है क्योंकि संग्रह के माध्यम से खोज करने वाली निम्न विधियाँ ठीक लगती हैं:

_.where([{"a": 1}, {"b": 2}], {"b": 2})
> {"b": 2}
_.find([{"a": 1}, {"b": 2}], {"b": 2})
> {"b": 2}

मैं क्या गलत कर रहा हूं? किसी संग्रह में किसी वस्तु की सदस्यता के लिए मैं कैसे जांच करूं includes?

संपादित करें: सवाल मूल रूप से लॉश संस्करण 2.4.1 के लिए था, जो कि लॉश 4.0.0 के लिए अद्यतन किया गया था

Comments

_.containsलश v4 में हटा दिया गया है - _.includesइसके बजाय का उपयोग करें

— बिली मून

@ बिली वूमन! हाँ, आप सही हैं, लॉश v4.0.0 (2016-01-12 जारी किया गया) containsउर्फ को हटा देता है । मैं इसे अपडेट

— करूंगा

Answer 1

includes(पूर्व में कहा जाता है containsऔर include) विधि संदर्भ द्वारा वस्तुओं तुलना (या अधिक सटीक, साथ ===)। क्योंकि {"b": 2}आपके उदाहरण में दो वस्तु शाब्दिक शब्द अलग-अलग उदाहरणों का प्रतिनिधित्व करते हैं, वे समान नहीं हैं। नोटिस:

({"b": 2} === {"b": 2})
> false

हालाँकि, यह काम करेगा क्योंकि इसमें केवल एक ही उदाहरण है {"b": 2}:

var a = {"a": 1}, b = {"b": 2};
_.includes([a, b], b);
> true

दूसरी ओर, where(v4 में पदावनत) और findविधियां उनके गुणों द्वारा वस्तुओं की तुलना करती हैं, इसलिए उन्हें संदर्भ समानता की आवश्यकता नहीं होती है। के विकल्प के रूप में includes, आप कोशिश करना चाहते हैं some(के रूप में भी उपनाम any):

_.some([{"a": 1}, {"b": 2}], {"b": 2})
> true

Answer 2

द्वारा जवाब का पूरक है p.s.w.g, यहाँ इस का उपयोग करने के बिनाlodash 4.17.5 , का उपयोग कर के तीन अन्य तरीके हैं : _.includes()

मान लें कि आप ऑब्जेक्ट entryको किसी ऑब्जेक्ट में जोड़ना चाहते हैं numbers, केवल तभी जब entryवह पहले से मौजूद न हो।

let numbers = [
    { to: 1, from: 2 },
    { to: 3, from: 4 },
    { to: 5, from: 6 },
    { to: 7, from: 8 },
    { to: 1, from: 2 } // intentionally added duplicate
];

let entry = { to: 1, from: 2 };

/* 
 * 1. This will return the *index of the first* element that matches:
 */
_.findIndex(numbers, (o) => { return _.isMatch(o, entry) });
// output: 0


/* 
 * 2. This will return the entry that matches. Even if the entry exists
 *    multiple time, it is only returned once.
 */
_.find(numbers, (o) => { return _.isMatch(o, entry) });
// output: {to: 1, from: 2}


/* 
 * 3. This will return an array of objects containing all the matches.
 *    If an entry exists multiple times, if is returned multiple times.
 */
_.filter(numbers, _.matches(entry));
// output: [{to: 1, from: 2}, {to: 1, from: 2}]

यदि आप Booleanपहले लौटना चाहते हैं , तो पहले मामले में, आप उस सूचकांक की जाँच कर सकते हैं जो वापस आ रहा है:

_.findIndex(numbers, (o) => { return _.isMatch(o, entry) }) > -1;
// output: true