जावास्क्रिप्ट में वस्तुओं के दो सरणियों के बीच अंतर कैसे प्राप्त करें


104

मेरे पास दो परिणाम सेट हैं:

// Result 1
[
    { value: "0", display: "Jamsheer" },
    { value: "1", display: "Muhammed" },
    { value: "2", display: "Ravi" },
    { value: "3", display: "Ajmal" },
    { value: "4", display: "Ryan" }
]

// Result 2
[
    { value: "0", display: "Jamsheer" },
    { value: "1", display: "Muhammed" },
    { value: "2", display: "Ravi" },
    { value: "3", display: "Ajmal" },
]

अंतिम परिणाम जो मुझे चाहिए वह इन सरणियों के बीच अंतर है - अंतिम परिणाम इस तरह होना चाहिए:

[{ value: "4", display: "Ryan" }]

क्या जावास्क्रिप्ट में ऐसा कुछ करना संभव है?


तो, आप उन सभी तत्वों की एक सरणी चाहते हैं जो मूल्य और प्रदर्शन द्वारा फ़िल्टर किए गए दोनों सरणियों में नहीं होते हैं?
सेरेब्रस

मैं दो सरणियों के बीच अंतर चाहता हूं। मान किसी भी एक सरणी में मौजूद होगा।
बीकेएम


2
फायरबग कंसोल में लॉग इन करते समय यह ऐरे जैसा दिखता है ...
माइक सी

2
क्षमा करें, लेकिन json ऑब्जेक्ट गलत है ... आपको बदलने की आवश्यकता है = के लिए:
वाल्टर ज़लज़ार

जवाबों:


141

केवल देशी JS का उपयोग करना, कुछ इस तरह से काम करेगा:

a = [{ value:"4a55eff3-1e0d-4a81-9105-3ddd7521d642", display:"Jamsheer"}, { value:"644838b3-604d-4899-8b78-09e4799f586f", display:"Muhammed"}, { value:"b6ee537a-375c-45bd-b9d4-4dd84a75041d", display:"Ravi"}, { value:"e97339e1-939d-47ab-974c-1b68c9cfb536", display:"Ajmal"},  { value:"a63a6f77-c637-454e-abf2-dfb9b543af6c", display:"Ryan"}]
b = [{ value:"4a55eff3-1e0d-4a81-9105-3ddd7521d642", display:"Jamsheer", $$hashKey:"008"}, { value:"644838b3-604d-4899-8b78-09e4799f586f", display:"Muhammed", $$hashKey:"009"}, { value:"b6ee537a-375c-45bd-b9d4-4dd84a75041d", display:"Ravi", $$hashKey:"00A"}, { value:"e97339e1-939d-47ab-974c-1b68c9cfb536", display:"Ajmal", $$hashKey:"00B"}]

function comparer(otherArray){
  return function(current){
    return otherArray.filter(function(other){
      return other.value == current.value && other.display == current.display
    }).length == 0;
  }
}

var onlyInA = a.filter(comparer(b));
var onlyInB = b.filter(comparer(a));

result = onlyInA.concat(onlyInB);

console.log(result);


1
यह काम करता है, और शायद सबसे अच्छा प्रत्यक्ष उत्तर है, लेकिन इसे किसी ऐसी चीज में बदलना अच्छा होगा जो एक विधेय और दो सूचियों को स्वीकार करता है और दो सूचियों के सममित अंतर को उचित रूप से लागू करके लौटाता है। (अतिरिक्त बिंदु यदि यह दो बार सभी m * n तुलनाओं के माध्यम से चलने की तुलना में अधिक कुशल थे!)
स्कॉट सौएट

@ScottSauyet: मैं "विधेय" शब्द से परिचित नहीं हूं (देशी अंग्रेजी बोलने वाला नहीं)। क्या यह return a.value ===...आपके उत्तर में है? (अच्छा समाधान, वैसे, +1) उपयोग करने के अलावा Array.prototype.some(), मैं वास्तव में ऐसा करने का अधिक कुशल / छोटा तरीका नहीं खोज सकता।
सेरेब्रस

2
@Cerbrus: हाँ। एक विधेय एक फ़ंक्शन है जो एक बूलियन ( trueया falseमान) लौटाता है । इस मामले में, यदि हम एक फ़ंक्शन के रूप में समानता की जांच पास करने के लिए उपयोगकर्ता की आवश्यकता के लिए बाकी कोड से समानता के लिए परीक्षण की धारणा को अलग करते हैं, तो हम कर सकते हैं एक सीधा जेनेरिक एल्गोरिथ्म।
स्कॉट सॉयट

@ScottSauyet: मुझे इस उत्तर को फिर से खोजने में थोड़ा समय लगा है, लेकिन अब यह थोड़ा बेहतर है: D
Cerbrus

ES6 const तुलना = (otherArray) => (वर्तमान) => otherArray.filter ((अन्य) => other.value == current.value && other.display == current.display) .length == 0;
शनीगी

70

आप के Array.prototype.filter()साथ संयोजन में उपयोग कर सकते हैं Array.prototype.some()

यहां एक उदाहरण दिया गया है (यह मानते हुए कि आपके सरणियों को चर में संग्रहीत किया जाता है result1और result2):

//Find values that are in result1 but not in result2
var uniqueResultOne = result1.filter(function(obj) {
    return !result2.some(function(obj2) {
        return obj.value == obj2.value;
    });
});

//Find values that are in result2 but not in result1
var uniqueResultTwo = result2.filter(function(obj) {
    return !result1.some(function(obj2) {
        return obj.value == obj2.value;
    });
});

//Combine the two arrays of unique entries
var result = uniqueResultOne.concat(uniqueResultTwo);

43

ES6 में वन-लाइनर समाधान पसंद करने वालों के लिए कुछ इस प्रकार है:

const arrayOne = [ 
  { value: "4a55eff3-1e0d-4a81-9105-3ddd7521d642", display: "Jamsheer" },
  { value: "644838b3-604d-4899-8b78-09e4799f586f", display: "Muhammed" },
  { value: "b6ee537a-375c-45bd-b9d4-4dd84a75041d", display: "Ravi" },
  { value: "e97339e1-939d-47ab-974c-1b68c9cfb536", display: "Ajmal" },
  { value: "a63a6f77-c637-454e-abf2-dfb9b543af6c", display: "Ryan" },
];
          
const arrayTwo = [
  { value: "4a55eff3-1e0d-4a81-9105-3ddd7521d642", display: "Jamsheer"},
  { value: "644838b3-604d-4899-8b78-09e4799f586f", display: "Muhammed"},
  { value: "b6ee537a-375c-45bd-b9d4-4dd84a75041d", display: "Ravi"},
  { value: "e97339e1-939d-47ab-974c-1b68c9cfb536", display: "Ajmal"},
];

const results = arrayOne.filter(({ value: id1 }) => !arrayTwo.some(({ value: id2 }) => id2 === id1));

console.log(results);


3
कृपया इसे समझाएं!
ब्रूनो ब्रिटो

15

मैं थोड़ा अधिक सामान्य-उद्देश्य दृष्टिकोण लेता हूं, हालांकि विचारों में @Cerbrus और @Kasper Moerch दोनों के समान हैं । मैं एक ऐसा फ़ंक्शन बनाता हूं जो यह निर्धारित करने के लिए एक विधेय को स्वीकार करता है कि क्या दो वस्तुएं समान हैं (यहां हम $$hashKeyसंपत्ति की उपेक्षा करते हैं, लेकिन यह कुछ भी हो सकता है) और एक ऐसा फ़ंक्शन लौटाता है जो उस विधेय के आधार पर दो सूचियों के सममित अंतर की गणना करता है:

a = [{ value:"4a55eff3-1e0d-4a81-9105-3ddd7521d642", display:"Jamsheer"}, { value:"644838b3-604d-4899-8b78-09e4799f586f", display:"Muhammed"}, { value:"b6ee537a-375c-45bd-b9d4-4dd84a75041d", display:"Ravi"}, { value:"e97339e1-939d-47ab-974c-1b68c9cfb536", display:"Ajmal"},  { value:"a63a6f77-c637-454e-abf2-dfb9b543af6c", display:"Ryan"}]
b = [{ value:"4a55eff3-1e0d-4a81-9105-3ddd7521d642", display:"Jamsheer", $$hashKey:"008"}, { value:"644838b3-604d-4899-8b78-09e4799f586f", display:"Muhammed", $$hashKey:"009"}, { value:"b6ee537a-375c-45bd-b9d4-4dd84a75041d", display:"Ravi", $$hashKey:"00A"}, { value:"e97339e1-939d-47ab-974c-1b68c9cfb536", display:"Ajmal", $$hashKey:"00B"}]

var makeSymmDiffFunc = (function() {
    var contains = function(pred, a, list) {
        var idx = -1, len = list.length;
        while (++idx < len) {if (pred(a, list[idx])) {return true;}}
        return false;
    };
    var complement = function(pred, a, b) {
        return a.filter(function(elem) {return !contains(pred, elem, b);});
    };
    return function(pred) {
        return function(a, b) {
            return complement(pred, a, b).concat(complement(pred, b, a));
        };
    };
}());

var myDiff = makeSymmDiffFunc(function(x, y) {
    return x.value === y.value && x.display === y.display;
});

var result = myDiff(a, b); //=>  {value="a63a6f77-c637-454e-abf2-dfb9b543af6c", display="Ryan"}

सेरेब्रस के दृष्टिकोण पर इसका एक मामूली फायदा है (जैसा कि कास्पर मॉर्च का दृष्टिकोण है) कि यह जल्दी बच जाता है; यदि यह एक मैच पाता है, तो यह बाकी सूची की जाँच करने में परेशान नहीं करता है। अगर मेरे पास कोई curryफ़ंक्शन होता, तो मैं इसे थोड़ा अलग तरीके से करता, लेकिन यह ठीक काम करता है।

व्याख्या

एक टिप्पणी ने शुरुआती लोगों के लिए अधिक विस्तृत स्पष्टीकरण के लिए कहा। यहाँ एक प्रयास है।

हम निम्न फ़ंक्शन पास करते हैं makeSymmDiffFunc:

function(x, y) {
    return x.value === y.value && x.display === y.display;
}

यह फ़ंक्शन है कि हम कैसे तय करते हैं कि दो ऑब्जेक्ट समान हैं। सभी कार्यों की तरह जो लौटते हैं trueया false, इसे "विधेय कार्य" कहा जा सकता है, लेकिन यह सिर्फ शब्दावली है। मुख्य बिंदु यह है कि makeSymmDiffFuncएक फ़ंक्शन के साथ कॉन्फ़िगर किया गया है जो दो वस्तुओं को स्वीकार करता है और trueअगर हम उन्हें नहीं मानते हैं तो रिटर्न देता है false

इसका उपयोग करते हुए, makeSymmDiffFunc("सममित अंतर फ़ंक्शन को पढ़ें") हमें एक नया फ़ंक्शन देता है:

        return function(a, b) {
            return complement(pred, a, b).concat(complement(pred, b, a));
        };

यह वह फ़ंक्शन है जिसका हम वास्तव में उपयोग करेंगे। हम इसे दो सूचियों को पास करते हैं और यह तत्वों को पहले नहीं दूसरे में पाता है, फिर दूसरे में नहीं पहली बार इन दो सूचियों को मिलाता है।

इसे फिर से देखते हुए, हालांकि, मैं निश्चित रूप से आपके कोड से एक क्यू ले सकता था और उपयोग करके मुख्य फ़ंक्शन को थोड़ा सरल किया some:

var makeSymmDiffFunc = (function() {
    var complement = function(pred, a, b) {
        return a.filter(function(x) {
            return !b.some(function(y) {return pred(x, y);});
        });
    };
    return function(pred) {
        return function(a, b) {
            return complement(pred, a, b).concat(complement(pred, b, a));
        };
    };
}());

complementविधेय का उपयोग करता है और अपनी पहली सूची के तत्वों को उसके दूसरे में नहीं लौटाता है। यह एक अलग containsफ़ंक्शन के साथ मेरे पहले पास की तुलना में सरल है ।

अंत में, मुख्य कार्य को आंतरिक कार्य समारोह को वैश्विक दायरे से बाहर रखने के लिए एक तुरंत लागू फ़ंक्शन अभिव्यक्ति ( IIFE ) में लपेटा जाता है complement


अद्यतन, कुछ साल बाद

अब जब ES2015 बहुत अच्छी तरह से सर्वव्यापी बन गया है, तो मैं एक ही तकनीक का सुझाव दूंगा, जिसमें बहुत कम बॉयलरप्लेट हो:

const diffBy = (pred) => (a, b) => a.filter(x => !b.some(y => pred(x, y)))
const makeSymmDiffFunc = (pred) => (a, b) => diffBy(pred)(a, b).concat(diffBy(pred)(b, a))

const myDiff = makeSymmDiffFunc((x, y) => x.value === y.value && x.display === y.display)

const result = myDiff(a, b)
//=>  {value="a63a6f77-c637-454e-abf2-dfb9b543af6c", display="Ryan"}

1
क्या आप अपने कोड में कुछ और स्पष्टीकरण जोड़ सकते हैं? मुझे यकीन नहीं है कि जावास्क्रिप्ट में एक शुरुआती समझ जाएगा कि विधेय-दृष्टिकोण कैसे काम करता है।
कास्परमोच

1
@ कैस्परमोचर: एक लंबा विवरण जोड़ा गया। मुझे आशा है कि वह मदद करेंगे। (इससे मुझे एक गंभीर सफाई भी मिली कि यह कोड होना चाहिए।)
स्कॉट सौएट

9
import differenceBy from 'lodash/differenceBy'

const myDifferences = differenceBy(Result1, Result2, 'value')

यह वस्तुओं की दो सरणियों के बीच का अंतर लौटाएगा, valueउनकी तुलना करने के लिए कुंजी का उपयोग करके । ध्यान दें कि समान मान वाली दो चीज़ों को वापस नहीं किया जाएगा, क्योंकि अन्य कुंजियों को अनदेखा किया जाता है।

यह लॉश का एक हिस्सा है ।


ऊपर दी गई json ऑब्जेक्ट गलत है। जब इस तरह से बदलाव की कोशिश करें = के लिए:
वाल्टर ज़लाज़र

7

आप सरणी में प्रत्येक वस्तु के लिए अद्वितीय मूल्य के रूप में कुंजियों के साथ एक ऑब्जेक्ट बना सकते हैं और फिर दूसरे ऑब्जेक्ट में कुंजी के अस्तित्व के आधार पर प्रत्येक सरणी को फ़िल्टर कर सकते हैं। यह ऑपरेशन की जटिलता को कम करता है।

ES6

let a = [{ value:"4a55eff3-1e0d-4a81-9105-3ddd7521d642", display:"Jamsheer"}, { value:"644838b3-604d-4899-8b78-09e4799f586f", display:"Muhammed"}, { value:"b6ee537a-375c-45bd-b9d4-4dd84a75041d", display:"Ravi"}, { value:"e97339e1-939d-47ab-974c-1b68c9cfb536", display:"Ajmal"},  { value:"a63a6f77-c637-454e-abf2-dfb9b543af6c", display:"Ryan"}];
let b = [{ value:"4a55eff3-1e0d-4a81-9105-3ddd7521d642", display:"Jamsheer", $$hashKey:"008"}, { value:"644838b3-604d-4899-8b78-09e4799f586f", display:"Muhammed", $$hashKey:"009"}, { value:"b6ee537a-375c-45bd-b9d4-4dd84a75041d", display:"Ravi", $$hashKey:"00A"}, { value:"e97339e1-939d-47ab-974c-1b68c9cfb536", display:"Ajmal", $$hashKey:"00B"}];

let valuesA = a.reduce((a,{value}) => Object.assign(a, {[value]:value}), {});
let valuesB = b.reduce((a,{value}) => Object.assign(a, {[value]:value}), {});
let result = [...a.filter(({value}) => !valuesB[value]), ...b.filter(({value}) => !valuesA[value])];
console.log(result);

ES5

var a = [{ value:"4a55eff3-1e0d-4a81-9105-3ddd7521d642", display:"Jamsheer"}, { value:"644838b3-604d-4899-8b78-09e4799f586f", display:"Muhammed"}, { value:"b6ee537a-375c-45bd-b9d4-4dd84a75041d", display:"Ravi"}, { value:"e97339e1-939d-47ab-974c-1b68c9cfb536", display:"Ajmal"},  { value:"a63a6f77-c637-454e-abf2-dfb9b543af6c", display:"Ryan"}];
var b = [{ value:"4a55eff3-1e0d-4a81-9105-3ddd7521d642", display:"Jamsheer", $$hashKey:"008"}, { value:"644838b3-604d-4899-8b78-09e4799f586f", display:"Muhammed", $$hashKey:"009"}, { value:"b6ee537a-375c-45bd-b9d4-4dd84a75041d", display:"Ravi", $$hashKey:"00A"}, { value:"e97339e1-939d-47ab-974c-1b68c9cfb536", display:"Ajmal", $$hashKey:"00B"}];

var valuesA = a.reduce(function(a,c){a[c.value] = c.value; return a; }, {});
var valuesB = b.reduce(function(a,c){a[c.value] = c.value; return a; }, {});
var result = a.filter(function(c){ return !valuesB[c.value]}).concat(b.filter(function(c){ return !valuesA[c.value]}));
console.log(result);


5

मुझे लगता है कि @Cerbrus समाधान हाजिर है। मैंने एक ही समाधान लागू किया है लेकिन बार-बार कोड को स्वयं के फ़ंक्शन (DRY) में निकाला है।

 function filterByDifference(array1, array2, compareField) {
  var onlyInA = differenceInFirstArray(array1, array2, compareField);
  var onlyInb = differenceInFirstArray(array2, array1, compareField);
  return onlyInA.concat(onlyInb);
}

function differenceInFirstArray(array1, array2, compareField) {
  return array1.filter(function (current) {
    return array2.filter(function (current_b) {
        return current_b[compareField] === current[compareField];
      }).length == 0;
  });
}

2

मुझे फ़िल्टर और कुछ का उपयोग करके यह समाधान मिला।

resultFilter = (firstArray, secondArray) => {
  return firstArray.filter(firstArrayItem =>
    !secondArray.some(
      secondArrayItem => firstArrayItem._user === secondArrayItem._user
    )
  );
};


1

यहां अधिकांश उत्तर जटिल हैं, लेकिन क्या यह काफी सरल है?

  1. चेक करें कि कौन सा सरणी लंबा है और इसे पहले पैरामीटर के रूप में प्रदान करें (यदि लंबाई समान है, तो पैरामीटर ऑर्डर में कोई फर्क नहीं पड़ता)
  2. सरणी 1 से अधिक पाएं।
  3. यह सरणी 2 में मौजूद है, तो array1 के वर्तमान पुनरावृत्ति तत्व के लिए
  4. अगर यह मौजूद नहीं है, की तुलना में
  5. इसे 'अंतर' सरणी में लाएँ
const getArraysDifference = (longerArray, array2) => {
  const difference = [];

  longerArray.forEach(el1 => {      /*1*/
    el1IsPresentInArr2 = array2.some(el2 => el2.value === el1.value); /*2*/

    if (!el1IsPresentInArr2) { /*3*/
      difference.push(el1);    /*4*/
    }
  });

  return difference;
}

ओ (एन ^ 2) जटिलता।


प्लस 1 जटिलता शामिल करने के लिए
delavago1999

1

आप b पर अंतर कर सकते हैं और b पर a में अंतर कर सकते हैं, फिर दोनों परिणामों को मर्ज कर सकते हैं

let a = [
    { value: "0", display: "Jamsheer" },
    { value: "1", display: "Muhammed" },
    { value: "2", display: "Ravi" },
    { value: "3", display: "Ajmal" },
    { value: "4", display: "Ryan" }
]

let b = [
    { value: "0", display: "Jamsheer" },
    { value: "1", display: "Muhammed" },
    { value: "2", display: "Ravi" },
    { value: "3", display: "Ajmal" }
]

// b diff a
let resultA = b.filter(elm => !a.map(elm => JSON.stringify(elm)).includes(JSON.stringify(elm)));

// a diff b
let resultB = a.filter(elm => !b.map(elm => JSON.stringify(elm)).includes(JSON.stringify(elm)));  

// show merge 
console.log([...resultA, ...resultB]);


0

मैंने एक सामान्यीकृत अंतर बनाया है जो किसी भी तरह की 2 वस्तुओं की तुलना करता है और एक संशोधन हैंडलर gist.github.com/bortunac "diff.js" का उपयोग करने के एक पूर्व चला सकता है :

old_obj={a:1,b:2,c:[1,2]}
now_obj={a:2 , c:[1,3,5],d:55}

इसलिए संपत्ति को संशोधित किया जाता है, बी को हटा दिया जाता है, सी संशोधित किया जाता है, डी जोड़ा जाता है

var handler=function(type,pointer){
console.log(type,pointer,this.old.point(pointer)," | ",this.now.point(pointer)); 

}

अब जैसे का उपयोग करें

df=new diff();
df.analize(now_obj,old_obj);
df.react(handler);

कंसोल दिखाएगा

mdf ["a"]  1 | 2 
mdf ["c", "1"]  2 | 3 
add ["c", "2"]  undefined | 5 
add ["d"]  undefined | 55 
del ["b"]  2 | undefined 

0

सबसे सामान्य और सरल तरीका:

findObject(listOfObjects, objectToSearch) {
    let found = false, matchingKeys = 0;
    for(let object of listOfObjects) {
        found = false;
        matchingKeys = 0;
        for(let key of Object.keys(object)) {
            if(object[key]==objectToSearch[key]) matchingKeys++;
        }
        if(matchingKeys==Object.keys(object).length) {
            found = true;
            break;
        }
    }
    return found;
}

get_removed_list_of_objects(old_array, new_array) {
    // console.log('old:',old_array);
    // console.log('new:',new_array);
    let foundList = [];
    for(let object of old_array) {
        if(!this.findObject(new_array, object)) foundList.push(object);
    }
    return foundList;
}

get_added_list_of_objects(old_array, new_array) {
    let foundList = [];
    for(let object of new_array) {
        if(!this.findObject(old_array, object)) foundList.push(object);
    }
    return foundList;
}

0

जब यह बड़े सरणियों की बात आती है तो मैं मैप ऑब्जेक्ट पसंद करता हूं।

// create tow arrays
array1 = Array.from({length: 400},() => ({value:Math.floor(Math.random() * 4000)}))
array2 = Array.from({length: 400},() => ({value:Math.floor(Math.random() * 4000)}))

// calc diff with some function
console.time('diff with some');
results = array2.filter(({ value: id1 }) => array1.some(({ value: id2 }) => id2 === id1));
console.log('diff results ',results.length)
console.timeEnd('diff with some');

// calc diff with map object
console.time('diff with map');
array1Map = {};
for(const item1 of array1){
    array1Map[item1.value] = true;
}
results = array2.filter(({ value: id2 }) => array1Map[id2]);
console.log('map results ',results.length)
console.timeEnd('diff with map');


0

जावास्क्रिप्ट में मैप्स हैं, जो O (1) प्रविष्टि और लुकअप समय प्रदान करते हैं। इसलिए इसे O (n) (और नहीं O (n as) में हल किया जा सकता है जैसा कि अन्य सभी उत्तर करते हैं)। उसके लिए, प्रत्येक वस्तु के लिए एक अद्वितीय आदिम (स्ट्रिंग / संख्या) कुंजी उत्पन्न करना आवश्यक है। JSON.stringifyतत्वों के क्रम से समानता प्रभावित हो सकती है , लेकिन यह काफी त्रुटिपूर्ण है:

 JSON.stringify({ a: 1, b: 2 }) !== JSON.stringify({ b: 2, a: 1 })

इसलिए, मैं एक सीमांकक लेता हूं जो किसी भी मान में प्रकट नहीं होता है और मैन्युअल रूप से एक स्ट्रिंग की रचना करता है:

const toHash = value => value.value + "@" + value.display;

फिर एक Map बन जाता है। जब कोई तत्व पहले से ही मानचित्र में मौजूद है, तो वह हटा दिया जाता है, अन्यथा यह जुड़ जाता है। इसलिए केवल विषम समय (केवल एक बार) शामिल किए जाने वाले तत्व बने हुए हैं। यह तभी काम करेगा जब तत्व प्रत्येक सरणी में अद्वितीय हों:

const entries = new Map();

for(const el of [...firstArray, ...secondArray]) {
  const key = toHash(el);
  if(entries.has(key)) {
    entries.delete(key);
  } else {
    entries.set(key, el);
  }
}

const result = [...entries.values()];


0

मुझे इस प्रश्न के बारे में पता चला, एक एरे में पहले आइटम को चुनने का तरीका खोजा गया जो किसी अन्य ऐरे में किसी भी मूल्य से मेल नहीं खाता है और इसे एरे.फीड () और एरे.फिल्टर () की तरह अंत में छांटने में कामयाब रहा। यह

var carList= ['mercedes', 'lamborghini', 'bmw', 'honda', 'chrysler'];
var declinedOptions = ['mercedes', 'lamborghini'];

const nextOption = carList.find(car=>{
    const duplicate = declinedOptions.filter(declined=> {
      return declined === car
    })
    console.log('duplicate:',duplicate) //should list out each declined option
    if(duplicate.length === 0){//if theres no duplicate, thats the nextOption
      return car
    }
})

console.log('nextOption:', nextOption);
//expected outputs
//duplicate: mercedes
//duplicate: lamborghini
//duplicate: []
//nextOption: bmw

अगर आपको अगले सबसे अच्छे विकल्प के लिए क्रॉस-चेकिंग से पहले एक अद्यतन सूची प्राप्त करने की आवश्यकता है तो यह अच्छी तरह से काम करना चाहिए :)


-3

यदि आप बाहरी पुस्तकालयों का उपयोग करने के इच्छुक हैं, तो आप इसे प्राप्त करने के लिए underscore.js में _.difference का उपयोग कर सकते हैं। _.difference सरणी से मान लौटाता है जो अन्य सरणियों में मौजूद नहीं हैं।

_.difference([1,2,3,4,5][1,4,10])

==>[2,3,5]

12
यह केवल आदिम मूल्यों के साथ सरणियों पर काम करता है। यदि सरणी में ऑब्जेक्ट्स की एक सूची है, जैसे यह प्रश्न पूछता है, तो यह काम नहीं करेगा क्योंकि यह ऑब्जेक्ट्स के बजाय स्वयं के संदर्भों की तुलना करने की कोशिश करता है, जो लगभग हमेशा इसका मतलब होगा कि सब कुछ अलग है।
रॉस पीपुल्स

1
धन्यवाद रॉस आपने मुझे सिरदर्द से बचाया। मैं एक बग को अंडरस्कोर करने की रिपोर्ट करने वाला था।
इटियेन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.