Tôi có hai mảng này: một mảng chứa đầy thông tin từ một yêu cầu ajax và một mảng khác lưu trữ các nút mà người dùng nhấp vào. Tôi sử dụng mã này (tôi đã điền số mẫu):

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

Nhưng nó luôn cho false, ngay cả khi hai mảng giống nhau, nhưng khác tên. (Tôi đã kiểm tra điều này trong Bảng điều khiển JS của Chrome). Vì vậy, có cách nào tôi có thể biết nếu hai mảng này chứa cùng một không? Tại sao nó lại cho false? Làm cách nào để biết giá trị nào trong mảng đầu tiên không nằm trong mảng thứ hai?

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;

}

Lưu ý rằng điều này không sửa đổi các mảng ban đầu không giống như câu trả lời trước đó.

Nếu các mục mảng của bạn không phải là đối tượng- ví dụ: nếu chúng là số hoặc chuỗi, bạn có thể so sánh các chuỗi đã nối của chúng để xem liệu chúng có các thành viên giống nhau theo bất kỳ thứ tự nào không-

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

Nếu bạn chỉ muốn kiểm tra xem hai mảng có cùng giá trị hay không (bất kể số lần xuất hiện và thứ tự của mỗi giá trị), bạn có thể thực hiện việc này bằng cách sử dụng lodash :

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

Ngắn gọn, đơn giản và đẹp!

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

Có lẽ?

Tại sao mã của bạn không hoạt động

JavaScript có kiểu dữ liệu nguyên thủy và kiểu dữ liệu không nguyên thủy.

Đối với các kiểu dữ liệu nguyên thủy ==và ===kiểm tra xem những thứ ở hai bên của thanh có cùng giá trị hay không. Đó là lý do tại sao 1 === 1là sự thật.

Đối với các kiểu dữ liệu không nguyên thủy như mảng ==và ===kiểm tra sự bình đẳng tham chiếu. Đó là, họ kiểm tra xem có arr1và arr2là cùng một đối tượng. Trong ví dụ của bạn, hai mảng có các đối tượng giống nhau theo cùng một thứ tự, nhưng không tương đương.

Các giải pháp

Hai mảng arr1và arr2có các thành viên giống nhau nếu và chỉ khi:

• Mọi thứ ở arr2trongarr1

VÀ

• Mọi thứ ở arr1trongarr2

Vì vậy, điều này sẽ thực hiện thủ thuật (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`

Giải pháp thứ hai sử dụng Dấu gạch dưới này gần hơn với những gì bạn đang cố gắng thực hiện:

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

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

Nó hoạt động vì isEqualkiểm tra "bình đẳng sâu", có nghĩa là nó xem xét nhiều hơn là chỉ tham chiếu bình đẳng và so sánh các giá trị.

Giải pháp cho câu hỏi thứ ba của bạn

Bạn cũng hỏi làm thế nào để tìm ra những thứ arr1không có trong đó arr2.

Điều này sẽ làm được điều đó (ES2015):

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

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

Bạn cũng có thể sử dụng differencephương pháp Underscore's ::

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

CẬP NHẬT

Xem bình luận của @ Redu — giải pháp của tôi là dành cho sameMembers, nhưng những gì bạn có thể nghĩ đến sameMembersInOrdercũng được gọi là deepEquals.

CẬP NHẬT 2

Nếu bạn không quan tâm đến thứ tự của các thành viên trong mảng, ES2015 + Setcó thể là một cấu trúc dữ liệu tốt hơn Array. Xem ghi chú MDN về cách thực hiện isSupersetvàdifference sử dụng miếng vá khỉ nguy hiểm.

Kiểm tra bình đẳng đối tượng:JSON.stringify(array1.sort()) === JSON.stringify(array2.sort())

Thử nghiệm trên cũng hoạt động với các mảng đối tượng trong trường hợp đó sử dụng hàm sắp xếp như được ghi trong http://www.w3schools.com/jsref/jsref_sort.asp

Có thể đủ cho các mảng nhỏ với lược đồ JSON phẳng.

Mục đích của chúng tôi về cơ bản là kiểm tra xem 2 mảng có phải là các tập hợp bằng nhau hay không. bộ là về mặt toán học được định nghĩa thiết lập . Sắp xếp nhanh nhất theo tiệm cận mất O (nlog (n)) thời gian. Vì vậy, Nếu bạn sắp xếp một mảng, sẽ mất ít nhất O (nlog (n)) thời gian. Nhưng bạn có thể thực hiện tác vụ này nhanh hơn , điều này theo tiệm cận mất O (n) thời gian (trường hợp trung bình không phải trường hợp xấu nhất) với cấu trúc dữ liệu từ điển. Trong JS, từ điển chỉ đơn giản là một đối tượng với các khóa và giá trị.

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

Lưu ý rằng hàm này hoạt động với các mảng có kiểu nguyên thủy và giả định a1và a2là mảng.

Cái này thì sao? ES 2017 tôi cho rằng:

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

Điều kiện thứ nhất kiểm tra xem cả hai mảng có cùng độ dài hay không và điều kiện thứ hai kiểm tra xem mảng thứ nhất có phải là tập con của mảng thứ hai hay không. Khi đó, kết hợp 2 điều kiện này sẽ dẫn đến việc so sánh tất cả các mục của 2 mảng bất kể thứ tự của các phần tử.

Đoạn mã trên sẽ chỉ hoạt động nếu cả hai mảng đều có các mục không trùng lặp.

Khi bạn so sánh hai mảng đó, bạn đang so sánh các đối tượng đại diện cho mảng chứ không phải nội dung.

Bạn sẽ phải sử dụng một hàm để so sánh hai hàm. Bạn có thể viết của riêng mình mà chỉ cần lặp lại một vòng và so sánh nó với cái kia sau khi bạn kiểm tra xem độ dài có giống nhau không.

Giải pháp đơn giản cho bình đẳng cạn sử dụng ES6:

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

Tạo các bản sao nông của từng mảng và sắp xếp chúng. Sau đó, sử dụng some()để lặp qua arr1testcác giá trị, kiểm tra từng giá trị so với giá trị trong arr2testcùng một chỉ mục. Nếu tất cả các giá trị bằng nhau, some()trả về falsevà lần lượt là equalgiá trị true.

Cũng có thể sử dụng every(), nhưng nó sẽ phải quay vòng qua mọi phần tử trong mảng để đáp ứng một truekết quả, trong khi some()nó sẽ bảo lưu ngay sau khi nó tìm thấy một giá trị không bằng:

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

Tôi có các giá trị số nguyên đơn giản trong một dự án Trò chơi
Có số lượng giá trị trong mỗi mảng ít hơn, đồng thời, cần mảng ban đầu đó không bị ảnh hưởng
Vì vậy, tôi đã làm như dưới đây, nó hoạt động tốt. (Đã chỉnh sửa mã để dán vào đây)

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;

Hy vọng rằng sẽ giúp.

Sử dụng ES6

Chúng ta sẽ sử dụng hàm của Ramda equals, nhưng thay vào đó chúng ta có thể sử dụng Lodash's hoặc Underscore isEqual:

const R = require('ramda');

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

Sử dụng bộ điều khiển lây lan, chúng tôi tránh làm thay đổi các mảng ban đầu và chúng tôi giữ nguyên hàm của mình.

Bạn có thể sử dụng reducethay vì các vòng lặp để tỏ ra thông minh, nhưng có nguy cơ bị các nhà phát triển đồng nghiệp coi bạn như một kẻ thông minh.

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

Nếu các mục trong mảng là nguyên thủy (số hoặc ký tự đơn), bạn có thể sử dụng kết hợp so sánh độ dài và sử dụng tập hợp.

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
}

Đã đến năm 2020 rồi nhưng tôi nhận thấy rằng hầu hết các giải pháp khác sử dụng sắp xếp, O (n * log n), sử dụng thư viện hoặc có độ phức tạp O (n ^ 2).

Đây là một giải pháp Javascript thuần túy với độ phức tạp tuyến tính, 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
}

Kiểm tra:

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

Nếu bạn đang sử dụng Khung nguyên mẫu, bạn có thể sử dụng phương pháp giao nhau của một mảng để tìm ra chúng giống nhau (bất kể thứ tự):

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

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

vui lòng kiểm tra câu trả lời này

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

Trả lời sau một thời gian dài nhưng hy vọng điều này sẽ giúp ích cho những ai đang tìm kiếm một giải pháp đơn giản và những người mới hiện đại.

Bây giờ chúng ta có thể đạt được điều này bằng cách sử dụng nhiều thư viện như lodash, underscorev.v. (Những thư viện này ngày nay trở thành một phần của dự án do tính đơn giản, nhiều tính năng và mức sử dụng cao)

Bạn có thể sử dụng giao điểm từ thư viện lodash.

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

Điều này sẽ hoạt động đối với bất kỳ loại dữ liệu nào ..

Nếu bạn muốn so sánh hai mảng và kiểm tra xem có đối tượng nào giống nhau trong cả hai mảng thì nó sẽ hoạt động. Thí dụ :

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

Ở đây, 'd' là chung trong cả hai mảng nên hàm này sẽ trả về giá trị true.

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

Thử cái này

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

Tôi có một cách khác dựa trên câu trả lời được chấp nhận.

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

Một chức năng để So sánh hai Mảng, để kiểm tra xem cả hai có cùng phần tử hay không. Ngay cả khi chúng không theo trật tự ...

Nó tốt cho các mảng đơn giản. [Chuỗi, Số, Boolean, null, NaN].

Tôi không sử dụng .sort (), nó sửa đổi mảng ban đầu. Một số người nói rằng nó tệ ...

Thận trọng. Chức năng này bị giới hạn, nó không thể so sánh các Đối tượng "[], {}" hoặc các hàm trong Mảng này, các mảng tự nó là Đối tượng.

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

Giải pháp đơn giản để so sánh hai mảng:

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

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

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