कैसे पता करें कि दो सरणियों में समान मान हैं

Question

मेरे पास ये दो सरणियाँ हैं: एक अजाक्स अनुरोध से जानकारी से भरा है और दूसरा उपयोगकर्ता द्वारा क्लिक किए जाने वाले बटन को संग्रहीत करता है। मैं इस कोड का उपयोग करता हूं (मैंने नमूना संख्याओं से भरा):

var array1 = [2, 4];
var array2 = [4, 2]; //It cames from the user button clicks, so it might be disordered.
array1.sort(); //Sorts both Ajax and user info.
array2.sort();
if (array1==array2) {
    doSomething();
}else{
    doAnotherThing();
}

लेकिन यह हमेशा देता है false, भले ही दो सरणियाँ समान हों, लेकिन अलग-अलग नाम के साथ। (मैंने इसे क्रोम के जेएस कंसोल में चेक किया)। तो, क्या कोई तरीका है जिससे मुझे पता चल सके कि क्या इन दो सरणियों में एक ही है? क्यों दे रहा है false? मैं कैसे जान सकता हूं कि पहले सरणी में कौन से मूल्य दूसरे में नहीं हैं?

Comments

मुझे पूरा यकीन है कि आपको सरणियों के प्रत्येक तत्व के माध्यम से जाने की आवश्यकता है।

— थॉमस ली

क्या आप जानते हैं कि यह असत्य क्यों है? जिज्ञासु।

— रॉब

@Andrew का उत्तर देखें stackoverflow.com/a/6229263/702565

— कार्लोस प्रेसीसो

जावास्क्रिप्ट सरणी बराबर की जाँच करने के लिए कैसे

— पलक

Answer 1

function arraysEqual(_arr1, _arr2) {

    if (!Array.isArray(_arr1) || ! Array.isArray(_arr2) || _arr1.length !== _arr2.length)
      return false;

    var arr1 = _arr1.concat().sort();
    var arr2 = _arr2.concat().sort();

    for (var i = 0; i < arr1.length; i++) {

        if (arr1[i] !== arr2[i])
            return false;

    }

    return true;

}

ध्यान दें कि यह पिछले उत्तर के विपरीत मूल सरणियों को संशोधित नहीं करता है।

Comments

छँटाई nlog (n) समय लेता है। आप छँटाई की जरूरत नहीं है यह उत्तर stackoverflow.com/a/55614659/3209523 रैखिक समय में काम करता है।

— कैनबक्स

Array.isArray () टाइपस्क्रिप्ट का उपयोग त्रुटियों को पैदा कर रहा था, यह हटाकर कि यह ठीक काम करता है।

— एरियल फ्रिशर

Answer 2

यदि आपके सरणी आइटम ऑब्जेक्ट नहीं हैं- यदि वे संख्या या तार हैं, उदाहरण के लिए, आप उनके शामिल किए गए तार की तुलना यह देखने के लिए कर सकते हैं कि क्या उनके पास किसी भी क्रम में समान सदस्य हैं-

var array1= [10, 6, 19, 16, 14, 15, 2, 9, 5, 3, 4, 13, 8, 7, 1, 12, 18, 11, 20, 17];
var array2= [12, 18, 20, 11, 19, 14, 6, 7, 8, 16, 9, 3, 1, 13, 5, 4, 15, 10, 2, 17];

if(array1.sort().join(',')=== array2.sort().join(',')){
    alert('same members');
}
else alert('not a match');

Comments

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

— devios1

धन्यवाद! साफ समाधान

— गैस्टन सांचेज़

अशक्त वस्तुओं और छँटाई से सावधान रहें। मैंने अपने मामले में ", 2,2,3" और "2,2,3" की तुलना करने के लिए तार के साथ समाप्त किया, जो निश्चित रूप से समान रूप से समान नहीं हैं।

— बारबरा.पोस्ट

तार, यानी के लिए विफल हो सकता है ['a', 'b']और ['a,b']। मैं इस तकनीक को केवल छोटी छोटी स्क्रिप्ट के लिए सुझाऊँगा।

— एलेक्स

@alex - मेरे मामले में, कॉमा को स्ट्रिंग्स में अनुमति दी जाती है लेकिन अर्ध कॉलोन नहीं हैं, इसलिए मैंने ';' अल्पविराम के बजाय शामिल होने के लिए

— a2345sooted

Answer 3

यदि आप केवल दो एरे को मान देना चाहते हैं, तो जाँच करें (भले ही प्रत्येक मूल्य की घटनाओं और क्रम की संख्या) आप लॉश का उपयोग करके ऐसा कर सकते हैं :

_.isEmpty(_.xor(array1, array2))

लघु, सरल और सुंदर!

Comments

मैं xorअंडरस्कोर डॉक्स में नहीं मिल सकता है? क्या आप IODash के बारे में सोच रहे हैं?

— पैट्रिक मेन्कियास-लुईस

Answer 4

Array.prototype.compare = function(testArr) {
    if (this.length != testArr.length) return false;
    for (var i = 0; i < testArr.length; i++) {
        if (this[i].compare) { //To test values in nested arrays
            if (!this[i].compare(testArr[i])) return false;
        }
        else if (this[i] !== testArr[i]) return false;
    }
    return true;
}

var array1 = [2, 4];
var array2 = [4, 2];
if(array1.sort().compare(array2.sort())) {
    doSomething();
} else {
    doAnotherThing();
}

शायद?

Comments

धन्यवाद! यह इच्छानुसार काम करता है। मैंने फ़ंक्शन को थोड़ा संशोधित किया ताकि मुझे यह भी पता चल सके कि कितने बेमेल हैं।

— कार्लोस प्रेसीसो

[2,4] [4,2] के लिए गलत है।

— सूरज ख़ानल

@ सुराज़खानल को अभी भी सॉर्ट करने की जरूरत है

— एरॉन

Answer 5

आपका कोड काम क्यों नहीं किया

जावास्क्रिप्ट में आदिम डेटा प्रकार और गैर-आदिम डेटा प्रकार होते हैं।

आदिम डेटा प्रकारों के लिए, ==और ===जांचें कि क्या सलाखों के दोनों ओर की चीजों का मूल्य समान है। इसलिए 1 === 1यह सच है।

गैर-आदिम डेटा प्रकारों के लिए सरणियाँ, ==और ===संदर्भ समानता के लिए जाँच करें। यही कारण है, वे या नहीं, इसका arr1और arr2एक ही वस्तु है। आपके उदाहरण में, दो सरणियों में समान क्रम में समान ऑब्जेक्ट हैं, लेकिन समतुल्य नहीं हैं।

समाधान

दो सरणियों, arr1और arr2, अगर और केवल अगर एक ही सदस्य हैं:

• में सब कुछ arr2हैarr1

तथा

• में सब कुछ arr1हैarr2

तो यह चाल चलेगा (ES2016):

const containsAll = (arr1, arr2) => 
                arr2.every(arr2Item => arr1.includes(arr2Item))

const sameMembers = (arr1, arr2) => 
                        containsAll(arr1, arr2) && containsAll(arr2, arr1);

sameMembers(arr1, arr2); // `true`

अंडरस्कोर का उपयोग करने वाला यह दूसरा समाधान आपके द्वारा किए जा रहे प्रयासों के करीब है:

arr1.sort();
arr2.sort();

_.isEqual(arr1, arr2); // `true`

यह काम करता है क्योंकि isEqual"गहरी समानता" के लिए चेक, इसका अर्थ है कि यह केवल संदर्भ समानता से अधिक दिखता है और मूल्यों की तुलना करता है।

आपके तीसरे प्रश्न का हल

आपने यह भी पूछा कि कैसे पता लगाया जाए कि कौन सी चीजें arr1इसमें निहित नहीं हैं arr2।

यह यह (ES2015) करेगा:

const arr1 = [1, 2, 3, 4];
const arr2 = [3, 2, 1];

arr1.filter(arr1Item => !arr2.includes(arr1Item)); // `[4]`

आप अंडरस्कोर की differenceविधि का उपयोग भी कर सकते हैं :

_.difference(arr1, arr2); // `[4]`

अपडेट करें

देखिए @ रेडू की टिप्पणी- मेरा समाधान तो है sameMembers, लेकिन आपके मन में जो हो सकता है, वह sameMembersInOrderभी जाना-माना है deepEquals।

अद्यतन २

यदि आप सरणियों के सदस्यों के आदेश की परवाह नहीं करते हैं, तो ES2015 + की Setतुलना में बेहतर डेटा संरचना हो सकती है Array। खतरनाक बंदर-पैचिंग को लागू करने isSupersetऔरdifference उपयोग करने के तरीके पर एमडीएन नोट देखें ।

Comments

आपके समाधान गलत हैं। "दो arrays, arr1 और arr2, एक ही सदस्य हैं यदि और केवल अगर: arr2 में सब कुछ arr1 में है और arr1 में सब कुछ arr2 में है" यह भी गलत है। यह एक सरणी है जो एक सेट नहीं है। अतः sameMembers([1,1,2],[2,1,2]);झूठा लौटना चाहिए।

— रेडु

@Redu का अनुमान है कि यह निर्भर करता है कि "समान सदस्य" का क्या अर्थ है - मैं इसका मतलब यह लेता हूं कि "समान सदस्य हैं।" मेरी राय में, sameMembers([1,1,2],[2,1,2])लौटना चाहिए true। sameMembersInOrder([1,1,2],[2,1,2])एकेए deepEquals([1,1,2],[2,1,2])वापस आ जाना चाहिए false।

— अधिकतम Heiber

आपका तीसरा समाधान arr1.filter...केवल जाँच के लिए काम करेगा यदि arr2 में arr1 के सभी तत्व हैं या नहीं, लेकिन इसके अलावा दूसरा तरीका नहीं है जिसकी आवश्यकता भी है।

— आकाश वर्मा

Answer 6

वस्तु समानता की जाँच:JSON.stringify(array1.sort()) === JSON.stringify(array2.sort())

उपरोक्त परीक्षण वस्तुओं के सरणियों के साथ भी काम करता है जिसमें मामला http://www.w3schools.com/jsref/jsref_sort.asp में दस्तावेज के रूप में एक प्रकार्य फ़ंक्शन का उपयोग करता है ।

फ्लैट JSON स्कीमा के साथ छोटे सरणियों के लिए पर्याप्त हो सकता है।

Answer 7

हमारा उद्देश्य मूल रूप से यह जांचना है कि 2 सरणियां समान सेट हैं या नहीं। सेट गणितीय रूप से परिभाषित सेट है । सबसे तेज़ छँटाई asymptotically O (nlog (n)) समय लेता है । इसलिए यदि आप एक सरणी को सॉर्ट करते हैं, तो कम से कम O (nlog (n)) समय लगेगा। लेकिन आप इस कार्य को तेजी से कर सकते हैं , जो asymptotically एक शब्दकोश डेटा संरचना के साथ O (n) समय (औसतन सबसे खराब स्थिति नहीं ) लेता है । जेएस में, एक शब्दकोष कुंजी और मूल्यों के साथ एक वस्तु है।

/** assumes array elements are primitive types
* check whether 2 arrays are equal sets.
* @param  {} a1 is an array
* @param  {} a2 is an array
*/
function areArraysEqualSets(a1, a2) {
  const superSet = {};
  for (const i of a1) {
    const e = i + typeof i;
    superSet[e] = 1;
  }

  for (const i of a2) {
    const e = i + typeof i;
    if (!superSet[e]) {
      return false;
    }
    superSet[e] = 2;
  }

  for (let e in superSet) {
    if (superSet[e] === 1) {
      return false;
    }
  }

  return true;
}

ध्यान दें कि यह फ़ंक्शन आदिम प्रकारों और ग्रहणों के सरणियों के साथ काम करता है a1और a2सरणियाँ हैं।

Answer 8

इस बारे में क्या? ES 2017 मैं मानता हूं:

const array1 = [1, 3, 5];
const array2 = [1, 5, 3];

const isEqual = (array1.length === array2.length) && (array1.every(val => array2.includes(val)));
console.log(isEqual);

पहली स्थिति जाँचती है कि दोनों सरणियों की लंबाई समान है और दूसरी स्थिति जाँचती है कि पहली सरणी 2 सरणी का सबसेट है। इन 2 स्थितियों के संयोजन के बाद तत्वों के क्रम के बावजूद 2 सरणियों की सभी वस्तुओं की तुलना में परिणाम होना चाहिए।

उपरोक्त कोड केवल तभी काम करेगा जब दोनों सरणियों में गैर-डुप्लिकेट आइटम हों।

Answer 9

जब आप उन दो सरणियों की तुलना करते हैं, तो आप उन वस्तुओं की तुलना कर रहे हैं जो सामग्री का नहीं, सरणियों का प्रतिनिधित्व करते हैं।

आपको दो की तुलना करने के लिए एक फ़ंक्शन का उपयोग करना होगा। आप अपनी खुद की लिख सकते हैं कि बस एक छोरों और एक के बाद दूसरे की तुलना करने के बाद आप देख सकते हैं कि लंबाई समान हैं।

Answer 10

ES6 का उपयोग करके उथले समानता के लिए सरल समाधान:

const arr1test = arr1.slice().sort()
const arr2test = arr2.slice().sort()
const equal = !arr1test.some((val, idx) => val !== arr2test[idx])

प्रत्येक सरणी की उथली प्रतियां बनाता है और उन्हें क्रमबद्ध करता है। फिर मूल्यों के some()माध्यम से लूप का उपयोग करता है arr1test, प्रत्येक मूल्य arr2testको उसी सूचकांक के साथ जांचता है। यदि सभी मान समान हैं, तो some()रिटर्न false, और बदले में equalमूल्यांकन करता है true।

उपयोग भी कर सकता है every(), लेकिन trueपरिणाम को संतुष्ट करने के लिए इसे सरणी में प्रत्येक तत्व के माध्यम से चक्र करना होगा , जबकि some()जैसे ही यह मान पाता है कि यह बराबर नहीं है:

const equal = arr1test.every((val, idx) => val === arr2test[idx])

Answer 11

एक गेम प्रोजेक्ट में मेरे पास सरल पूर्णांक मान थे
, प्रत्येक सरणी में मानों की संख्या कम थी, इसके अलावा, मूल सरणी से अछूता
था, इसलिए मैंने नीचे किया, यह ठीक काम किया। (यहां पेस्ट करने के लिए संपादित कोड)

var sourceArray = [1, 2, 3];
var targetArray = [3, 2, 1];

if (sourceArray.length !== targetArray.length) {
    // not equal
    // did something
    return false;
}

var newSortedSourceArray = sourceArray.slice().sort();
var newSortedTargetArray = targetArray.slice().sort();

if (newSortedSourceArray.toString() !== newSortedTargetArray.toString()) { // MAIN CHECK
    // not equal
    // did something
    return false;
}
else {
    // equal
    // did something
    // continued further below
}

// did some more work

return true;

उम्मीद है की वो मदद करदे।

Answer 12

ES6 का उपयोग करना

हम रामदा के equalsफंक्शन का उपयोग करेंगे , लेकिन इसके बजाय हम लोडश या अंडरस्कोर का उपयोग कर सकते हैं isEqual:

const R = require('ramda');

const arraysHaveSameValues = (arr1, arr2) => R.equals( [...arr1].sort(), [...arr2].sort() )

स्प्रेड ऑप्रेटर का उपयोग करके, हम मूल सरणियों को बदलने से बचते हैं, और हम अपने कार्य को शुद्ध रखते हैं।

Answer 13

आप reduceचतुर दिखने के लिए छोरों के बजाय का उपयोग कर सकते हैं , लेकिन आपके साथी डेवलपर्स को आप एक स्मार्ट-गधा के रूप में सोचते हैं।

function isArrayContentSame(a, b) {
  if (Array.isArray(a) && Array.isArray(b) && a.length == b.length) {
    a = a.concat().sort()
    b = b.concat().sort()
    return a.reduce((acc,e,i) => acc && e === b[i], true)
  } else {
    return false;
  }
}

Answer 14

यदि सरणी में आइटम आदिम (संख्या या एकल वर्ण) हैं, तो आप लंबाई की तुलना करने और सेट का उपयोग करने के संयोजन का उपयोग कर सकते हैं।

function equalArrayItems(arr1, arr2) {
  if (arr1.length !== arr2.length) return false
  const set1 = new Set(arr1)
  const set2 = new Set(arr2)
  const set3 = new Set(arr1, arr2)
  return set1.size === set3.size && set2.size === set3.size
}

Answer 15

यह 2020 पहले से ही है, लेकिन मैंने देखा कि अधिकांश अन्य समाधान सॉर्ट, ओ (एन * लॉग एन) का उपयोग करते हैं, पुस्तकालयों का उपयोग करते हैं या ओ (एन ^ 2) जटिलता है।

यहाँ रैखिक जटिलता के साथ एक शुद्ध जावास्क्रिप्ट समाधान है, O (n):

/**
 * Check if two arrays of strings or numbers have the same values regardless of the order
 * @param {string[]|number[]} arr1
 * @param {string[]|number[]} arr2
 * @return {boolean}
 */    
compareArrays = (arr1, arr2) => {
    if (arr1.length !== arr2.length) return false;
    const lk1 = {};
    const lk2 = {};
    let i = arr1.length;
    while (--i >= 0) {
        lk1[arr1[i]] = true;
        lk2[arr2[i]] = true
    }
    i = arr1.length;
    while (--i >= 0) {
        const v = arr1[i];
        if (lk1[v] !== lk2[v]) return false;
    }
    return true
}

टेस्ट:

compareArrays([2, 4], [4, 2]) => true
compareArrays([2, 4], [4, 2, 7]) => false
compareArrays([], []) => true

Comments

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

— कार्लोस प्रीसीसो

@CarlosPrecioso यह सही है और O (2n) = O (n) है। जटिलता एक स्थिर कारक

— SC1000

Answer 16

यदि आप प्रोटोटाइप फ्रेमवर्क का उपयोग कर रहे हैं, तो आप एक सरणी के प्रतिच्छेदन विधि का उपयोग करके पता लगा सकते हैं कि वे समान हैं (आदेश की परवाह किए बिना):

var array1 = [1,2];
var array2 = [2,1];

if(array1.intersect(array2).length === array1.length) {
    alert("arrays are the same!");
}

Comments

यह काम नहीं करता है - [1,2].intersect([1,2,3]).length === [1,2].lengthसच है। आपको मूल सरणियों की लंबाई भी तुलना करनी चाहिए, मैंने पोस्ट को प्रदर्शित करने के लिए संपादित किया है।

— GMA

वास्तव में मैंने महसूस किया है कि मेरा सुझाया हुआ एडिट डुप्लिकेट के मामले में काम नहीं करता है ... उदाहरण के लिए यह गलत होगा array1 = [1,1,2]; array2 = [1,1,2];... मूल उत्तर उस इनपुट के लिए विफल नहीं होता है।

— GMA

आप इसके विपरीत_.difference(array1, array2).length;

— विक

Answer 17

कृपया इस उत्तर की जाँच करें

var arr1= [12,18];
var arr2= [12, 18, 20, 11, 19, 14, 6, 7, 8, 16, 9, 3, 1, 13, 5, 4, 15, 10, 2, 17];
for(i=0;i<arr1.length;i++)
{
var array1=arr1[i];
for(j=0;j<arr2.length;j++)
{
    var array2=arr2[j];
    if(array1==array2)
    {
return true;
    }
}
}

Comments

यह कार्यात्मक रूप से इस उत्तर के बराबर है , कुछ त्रुटियों के लिए बचाएं। सबसे पहले, यह सब एक फ़ंक्शन के भीतर लपेटा जाना चाहिए, या returnइच्छाशक्ति पर कोई प्रभाव नहीं पड़ेगा। दूसरा, आपको हल किए गए सरणियों की जांच करनी चाहिए, जैसा कि पता लगाया जाएगा [1,2]और [2,1]समान नहीं होगा। तीसरा और सबसे महत्वपूर्ण, यह वास्तव में केवल तभी जांच करेगा कि कोई तत्व समान है या नहीं। सशर्त होना चाहिए if (array1!==array2) {return false;}। शायद यह भविष्य में आपकी मदद कर सकता है!

— कार्लोस प्रीसीसो

और एक अतिरिक्त टिप्पणी के रूप में, कोड प्रवाह की बेहतर समझ के लिए इंडेंटेशन का उपयोग करने की कोशिश करें, साथ ही साथ स्पष्ट चर नाम भी। जैसे: array1और array2नाम बदला जा सकता है elem1और elem2। ये दोनों टिप्स आपको भविष्य में काफी सिरदर्द से बचाएंगे!

— कार्लोस प्रीसीसो

आगे के निरीक्षण पर, डबल लूप क्यों? दोनों सरणियों की लंबाई समान होनी चाहिए, और यदि नहीं, तो वे सीधे समान नहीं हैं। इस तरह आप केवल एक लूप का उपयोग कर सकते हैं। अभी, इस कोड को जांच करता है कि किसी भी पहली सरणी के तत्वों में से हैं कहीं भी एक दूसरे में। यह देखने के लिए कि आपको इसे कैसे लागू करना चाहिए, इस उत्तर की जाँच करें । अपने जावास्क्रिप्ट यात्रा में गुड लक!

— कार्लोस प्रीसीसो

Answer 18

लंबे समय के बाद जवाब देना लेकिन उम्मीद है कि यह किसी ऐसे व्यक्ति की मदद करेगा जो एक सरल समाधान और आधुनिक newbies की तलाश में है।

अब हम इस तरह कई पुस्तकालयों का उपयोग कर प्राप्त कर सकते हैं lodash, underscoreआदि (ये सादगी, एक से अधिक सुविधाओं और उच्च उपयोग के कारण आजकल परियोजना का हिस्सा हो जाता है)

आप लॉश लाइब्रेरी से चौराहे का उपयोग कर सकते हैं।

_.intersection(['2-1', '1'], ['2-2', '3-1', '2-1']); 
// => ['2-1']

यह किसी भी डेटा प्रकार के लिए काम करेगा।

Answer 19

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

Array1 = [a, b, c, d]
Array2 = [d, e, f, g]

यहाँ, 'd' दोनों ऐरे में कॉमन है इसलिए यह फंक्शन सही वैल्यू लौटाएगा।

  cehckArray(array1, array2) {
    for (let i = 0; i < array1.length; i++) {
      for (let j = 0; j < array2.length; j++) {
        if (array1[i] === array2[j]) {
          return true;
        }
      }
    }
    // Return if no common element exist 
    return false;
  }

Answer 20

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

function arraysEqual(arr1, arr2){
    if (!Array.isArray(arr1) || !Array.isArray(arr2) || arr1.length!=arr2.length)
        return false;

    return arr1.length==arr1.filter(word => arr2.includes(word)).length;
}

Answer 21

मेरे पास स्वीकृत उत्तर के आधार पर एक और तरीका है।

function compareArrays(array1, array2) {

    if (
        !Array.isArray(array1)
        || !Array.isArray(array2)
        || array1.length !== array2.length
    ) return false;

    var first = array1.sort().map(value => (String(value))).join();
    var second = array2.sort().map(value => (String(value))).join();

    return first == second ? true : false;
}

Comments

अरे, StackOverflow में आपका स्वागत है! हालांकि यह जवाब कुछ मामलों में काम करेगा, लेकिन कुछ विशिष्ट मामले ऐसे होंगे जहां यह नहीं होगा। सबसे पहले, ध्यान रखें कि .sort () मूल सरणी को संशोधित करता है। आजकल जिसे खराब स्वच्छता माना जाता है, इसीलिए मूल उत्तर प्रतिलिपि बनाने के लिए .concat () पहले करता है।

— कार्लोस प्रीसीसो

और दूसरा बिंदु, यह जावास्क्रिप्ट के बाकी हिस्सों के साथ लगातार काम नहीं करेगा। {foo: "bar"} === {foo: "bar"} झूठा लौटता है (वे अलग से बनाई गई दो अलग-अलग वस्तुएं हैं); इसलिए तुलनाअरे ([{फू: "बार"}], [{फू: "बार"}]), को भी संगति के लिए गलत लौटना चाहिए। हालांकि, आपके कार्यान्वयन के साथ, यह सही है, क्योंकि वस्तुओं का स्ट्रिंग प्रतिनिधित्व समान है। यह एक वांछित व्यवहार हो सकता है, या नहीं, लेकिन किसी भी मामले में सावधान रहने के लिए।

— कार्लोस प्रीसीसो

Answer 22

दो एरर्स की तुलना करने के लिए एक फ़ंक्शन, यह जांचने के लिए कि क्या दोनों में समान तत्व हैं। भले ही वे आउट ऑफ ऑर्डर हों ...

यह सरल सरणियों के लिए अच्छा है। [स्ट्रिंग, संख्या, बूलियन, शून्य, nan]।

मैं .sort () का उपयोग नहीं करता, यह मूल सरणी को संशोधित करता है। कुछ कहते हैं इसका बुरा ...

सावधान। यह फ़ंक्शन सीमित है यह वस्तुओं की तुलना "[], {}" या इन Arrays के भीतर नहीं कर सकता है, सरणियाँ यह स्व है ऑब्जेक्ट हैं।

   let arraysHasSameElements = (arr1, arr2) => {
        let count =
            // returns counting of occurrences.
            (arr, val) => arr.reduce((count, curr) => (curr === val ? 1 : 0) + count, 0);

        /* this will return true if lengths of the arrays is equal.
           then compare them.*/
        return arr1.length === arr2.length

            // compare arr1 against arr2.
            && arr1.reduce((checks, val) =>

                /*  creating array of checking if a value has equal amount of occurrences
                    in both arrays, then adds true 'check'. */
                checks.concat(count(arr1, val) === count(arr2, val)), [])

                // checking if each check is equal to true, then .every() returns true.
                .every(check => check);
    }

    let arr1 = ['',-99,true,NaN,21,null,false,'help',-99,'help',NaN], 
        arr2 = [null,-99,'',NaN,NaN,false,true,-99,'help',21,'help'];
    arraysHasSameElements(arr1, arr2); //true

    let arr3 = [false,false,false,false,false,false], 
        arr4 = [false,false,false,false,false,false]
    arraysHasSameElements(arr3, arr4); //true


    // here we have uncommented version.
    let arraysHasSameElements = (arr1, arr2) => {
        let count = (arr, val) => arr.reduce((count, curr) => (curr === val ? 1:0) + count, 0);
        return arr1.length === arr2.length && arr1.reduce((checks, val) =>
            checks.concat(count(arr1, val) === count(arr2, val)), []).every(check => check);
    }

Answer 23

दो सरणियों की तुलना करने के लिए सरल समाधान:

var array1 = [2, 4];
var array2 = [4, 2];

array1.sort();
array2.sort();

if (array1[0] == array2[0]) {
    console.log("Success");
}else{
    console.log("Wrong");
}