ฉันมีสองอาร์เรย์: อันหนึ่งเต็มไปด้วยข้อมูลจากคำขอ ajax และอีกอันเก็บปุ่มที่ผู้ใช้คลิก ฉันใช้รหัสนี้ (ฉันกรอกตัวเลขตัวอย่าง):

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แม้ว่าทั้งสองอาร์เรย์จะเหมือนกัน แต่มีชื่อต่างกัน (ฉันตรวจสอบสิ่งนี้ในคอนโซล JS ของ Chrome) ดังนั้นมีวิธีใดบ้างที่ฉันจะทราบได้ว่าอาร์เรย์ทั้งสองนี้มีอาร์เรย์เหมือนกัน ทำไมถึงให้false? ฉันจะรู้ได้อย่างไรว่าค่าใดในอาร์เรย์แรกที่ไม่อยู่ในอาร์เรย์ที่สอง

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;

}

โปรดทราบว่าสิ่งนี้ไม่ได้แก้ไขอาร์เรย์ดั้งเดิมซึ่งแตกต่างจากคำตอบก่อนหน้านี้

หากรายการอาร์เรย์ของคุณไม่ใช่วัตถุ - หากเป็นตัวเลขหรือสตริงคุณสามารถเปรียบเทียบสตริงที่รวมเข้าด้วยกันเพื่อดูว่ามีสมาชิกเหมือนกันในลำดับใด -

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');

หากคุณต้องการตรวจสอบเฉพาะว่าอาร์เรย์สองอาร์เรย์มีค่าเท่ากันหรือไม่ (โดยไม่คำนึงถึงจำนวนครั้งที่เกิดขึ้นและลำดับของแต่ละค่า) คุณสามารถทำได้โดยใช้lodash :

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

สั้น ๆ ง่ายๆและสวย!

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();
}

อาจจะ?

เหตุใดรหัสของคุณจึงไม่ทำงาน

JavaScript มีประเภทข้อมูลดั้งเดิมและประเภทข้อมูลที่ไม่ใช่พื้นฐาน

สำหรับชนิดข้อมูลดั้งเดิม==และ===ตรวจสอบว่าสิ่งที่อยู่ด้านใดด้านหนึ่งของแท่งมีค่าเท่ากันหรือไม่ นั่นเป็นเหตุผลว่าทำไมจึง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]`

คุณยังสามารถใช้ Underscore's difference: method:

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

อัปเดต

ดูความคิดเห็นของ @ Redu - ทางออกของฉันมีไว้สำหรับsameMembersแต่สิ่งที่คุณอาจคิดไว้ในใจก็เป็นที่sameMembersInOrderรู้จักเช่นdeepEqualsกัน

อัปเดต 2

หากคุณไม่สนใจเกี่ยวกับการสั่งซื้อของสมาชิกของอาร์เรย์ที่ ES2015 + 's อาจจะเป็นโครงสร้างข้อมูลที่ดีกว่าSet Arrayดูหมายเหตุของ MDN เกี่ยวกับวิธีการติดตั้งisSupersetและการdifferenceใช้งาน Monkey-patching ที่เป็นอันตราย

การตรวจสอบความเท่าเทียมกันของวัตถุ:JSON.stringify(array1.sort()) === JSON.stringify(array2.sort())

การทดสอบข้างต้นยังใช้ได้กับอาร์เรย์ของออบเจ็กต์ซึ่งในกรณีนี้จะใช้ฟังก์ชันการจัดเรียงตามที่ระบุไว้ในhttp://www.w3schools.com/jsref/jsref_sort.asp

อาจเพียงพอสำหรับอาร์เรย์ขนาดเล็กที่มีสคีมา JSON แบบแบน

จุดมุ่งหมายของเราคือการตรวจสอบว่าอาร์เรย์ 2 ชุดเท่ากันหรือไม่ ชุดเป็นที่กำหนดไว้ทางคณิตศาสตร์ชุด ที่เร็วที่สุดในการเรียงลำดับ asymptotically ใช้เวลาO (NLog (N))เวลา ดังนั้นหากคุณจัดเรียงแถวก็จะใช้เวลาอย่างน้อยO (NLog (N))เวลา แต่คุณสามารถทำงานนี้ได้เร็วขึ้นซึ่งใช้เวลาO (n)ตามอาการ (กรณีเฉลี่ยไม่ใช่กรณีที่เลวร้ายที่สุด) ด้วยโครงสร้างข้อมูลพจนานุกรม ใน JS พจนานุกรมเป็นเพียงวัตถุที่มีคีย์และค่า

/** 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เป็นอาร์เรย์

อะไรประมาณนี้ 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);

เงื่อนไขที่ 1 ตรวจสอบว่าอาร์เรย์ทั้งสองมีความยาวเท่ากันหรือไม่และเงื่อนไขที่ 2 จะตรวจสอบว่าอาร์เรย์ที่ 1 เป็นส่วนย่อยของอาร์เรย์ที่ 2 หรือไม่ การรวม 2 เงื่อนไขนี้ควรทำให้เกิดการเปรียบเทียบรายการทั้งหมดของ 2 อาร์เรย์โดยไม่คำนึงถึงลำดับขององค์ประกอบ

โค้ดด้านบนจะใช้ได้ก็ต่อเมื่ออาร์เรย์ทั้งสองมีรายการที่ไม่ซ้ำกัน

เมื่อคุณเปรียบเทียบทั้งสองอาร์เรย์คุณกำลังเปรียบเทียบวัตถุที่แสดงถึงอาร์เรย์ไม่ใช่เนื้อหา

คุณจะต้องใช้ฟังก์ชันเพื่อเปรียบเทียบทั้งสอง คุณสามารถเขียนของคุณเองที่วนซ้ำไปมาและเปรียบเทียบกับอีกอันหลังจากที่คุณตรวจสอบแล้วว่าความยาวเท่ากัน

วิธีง่ายๆสำหรับความเท่าเทียมกันตื้น ๆ โดยใช้ 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และในทางกลับประเมินequaltrue

สามารถใช้งานได้every()เช่นกัน แต่จะต้องวนรอบทุกองค์ประกอบในอาร์เรย์เพื่อให้เป็นไปตามtrueผลลัพธ์ในขณะที่some()จะประกันตัวทันทีที่พบค่าที่ไม่เท่ากัน:

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

ฉันมีค่าจำนวนเต็มอย่างง่ายในโครงการเกม
มีจำนวนค่าน้อยกว่าในแต่ละอาร์เรย์และต้องการอาร์เรย์ดั้งเดิมที่ไม่มีใครแตะต้อง
ดังนั้นฉันจึงทำตามด้านล่างนี้มันก็ใช้ได้ดี (รหัสแก้ไขเพื่อวางที่นี่)

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;

หวังว่าจะช่วยได้

ใช้ ES6

เราจะใช้equalsฟังก์ชันของ Ramda แต่เราสามารถใช้ Lodash's หรือ Underscore แทนได้isEqual:

const R = require('ramda');

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

การใช้ตัวควบคุมการแพร่กระจายเราจะหลีกเลี่ยงการกลายพันธุ์ของอาร์เรย์เดิมและเรารักษาฟังก์ชันของเราให้บริสุทธิ์

คุณสามารถใช้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;
  }
}

โซลูชันอื่น ๆ ส่วนใหญ่ใช้การเรียงลำดับ O (n * log n) ใช้ไลบรารีหรือมีความซับซ้อน O (n ^ 2)

นี่คือโซลูชัน Javascript แท้ที่มีความซับซ้อนเชิงเส้น O (n):

/**
 * Check if two arrays of strings or numbers have the same values
 * @param {string[]|number[]} arr1
 * @param {string[]|number[]} arr2
 * @param {Object} [opts]
 * @param {boolean} [opts.enforceOrder] - By default (false), the order of the values in the arrays doesn't matter.
 * @return {boolean}
 */
function compareArrays(arr1, arr2, opts) {

  function vKey(i, v) {
    return (opts?.enforceOrder ? `${i}-` : '') + `${typeof v}-${v}`
  }

  if (arr1.length !== arr2.length) return false;

  const d1 = {};
  const d2 = {};  
  for (let i = arr1.length - 1; i >= 0; i--) {
    d1[vKey(i, arr1[i])] = true;
    d2[vKey(i, arr2[i])] = true;
  }
  
  for (let i = arr1.length - 1; i >= 0; i--) {
    const v = vKey(i, arr1[i]);
    if (d1[v] !== d2[v]) return false;
  }

  for (let i = arr2.length - 1; i >= 0; i--) {
    const v = vKey(i, arr2[i]);
    if (d1[v] !== d2[v]) return false;
  }

  return true
}

การทดสอบ:

arr1= [1, 2]
arr2= [1, 2]
compareArrays(arr1, arr2) => true
compareArrays(arr1, arr2, {enforceOrder: true}) => true
-------
arr1= [1, 2]
arr2= [2, 1]
compareArrays(arr1, arr2) => true
compareArrays(arr1, arr2, {enforceOrder: true}) => false
-------
arr1= [2, 1]
arr2= [1, 2]
compareArrays(arr1, arr2) => true
compareArrays(arr1, arr2, {enforceOrder: true}) => false
-------
arr1= [2, 2]
arr2= [1, 2]
compareArrays(arr1, arr2) => false
compareArrays(arr1, arr2, {enforceOrder: true}) => false
-------
arr1= [1, 2]
arr2= [1, 2, 3]
compareArrays(arr1, arr2) => false
compareArrays(arr1, arr2, {enforceOrder: true}) => false
-------
arr1= ["1"]
arr2= [1]
compareArrays(arr1, arr2) => false
compareArrays(arr1, arr2, {enforceOrder: true}) => false
-------
arr1= ["1", 2]
arr2= [2, "1"]
compareArrays(arr1, arr2) => true
compareArrays(arr1, arr2, {enforceOrder: true}) => false
-------
arr1= []
arr2= []
compareArrays(arr1, arr2) => true
compareArrays(arr1, arr2, {enforceOrder: true}) => true

หากคุณใช้ Prototype Framework คุณสามารถใช้วิธีการตัดกันของอาร์เรย์เพื่อค้นหาว่ามันเหมือนกัน (ไม่ว่าจะเรียงลำดับอย่างไร):

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

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

โปรดตรวจสอบคำตอบนี้

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;
    }
}
}

ตอบหลังจากผ่านไปนาน แต่หวังว่านี่จะช่วยคนที่กำลังมองหาวิธีง่ายๆและมือใหม่สมัยใหม่

ตอนนี้เราสามารถบรรลุนี้โดยใช้ห้องสมุดหลายเช่นlodash, underscoreฯลฯ (เหล่านี้จะกลายเป็นส่วนหนึ่งของโครงการในปัจจุบันเนื่องจากความเรียบง่าย, คุณสมบัติหลายและการใช้งานที่สูง)

คุณสามารถใช้ทางแยกจากห้องสมุด lodash

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

สิ่งนี้จะใช้ได้กับข้อมูลทุกประเภท ..

หากคุณต้องการเปรียบเทียบอาร์เรย์สองอาร์เรย์และตรวจสอบว่าวัตถุใดเหมือนกันในทั้งสองอาร์เรย์ก็จะใช้งานได้ ตัวอย่าง:

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;
  }

ลองทำตามนี้

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;
}

ฉันมีวิธีอื่นตามคำตอบที่ยอมรับ

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;
}

ฟังก์ชันเปรียบเทียบสองอาร์เรย์เพื่อตรวจสอบว่าทั้งสองมีองค์ประกอบเดียวกันหรือไม่ แม้ว่าพวกเขาจะออกคำสั่ง ...

เหมาะสำหรับอาร์เรย์ธรรมดา [String, Number, Boolean, null, NaN]

ฉันไม่ได้ใช้ .ort () มันแก้ไขอาร์เรย์เดิม บางคนบอกว่ามันแย่ ...

ข้อควรระวัง. ฟังก์ชันนี้มีข้อ จำกัด ไม่สามารถเปรียบเทียบ Objects "[], {}" หรือฟังก์ชันภายใน Arrays เหล่านี้ได้อาร์เรย์ของตัวเองคือ Objects

   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);
    }

วิธีง่ายๆในการเปรียบเทียบสองอาร์เรย์:

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

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

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