Làm thế nào để so sánh các mảng trong JavaScript?

Tôi muốn so sánh hai mảng ... lý tưởng, hiệu quả. Không có gì lạ mắt, chỉ cần truechúng giống hệt nhau, và falsenếu không. Không có gì đáng ngạc nhiên, toán tử so sánh dường như không hoạt động.

var a1 = [1,2,3];
var a2 = [1,2,3];
console.log(a1==a2);    // Returns false
console.log(JSON.stringify(a1)==JSON.stringify(a2));    // Returns true

JSON mã hóa từng mảng, nhưng có cách nào nhanh hơn hoặc "tốt hơn" để đơn giản so sánh các mảng mà không phải lặp qua từng giá trị?

Để so sánh các mảng, lặp qua chúng và so sánh mọi giá trị:

So sánh mảng:

// Warn if overriding existing method
if(Array.prototype.equals)
    console.warn("Overriding existing Array.prototype.equals. Possible causes: New API defines the method, there's a framework conflict or you've got double inclusions in your code.");
// attach the .equals method to Array's prototype to call it on any array
Array.prototype.equals = function (array) {
    // if the other array is a falsy value, return
    if (!array)
        return false;

    // compare lengths - can save a lot of time 
    if (this.length != array.length)
        return false;

    for (var i = 0, l=this.length; i < l; i++) {
        // Check if we have nested arrays
        if (this[i] instanceof Array && array[i] instanceof Array) {
            // recurse into the nested arrays
            if (!this[i].equals(array[i]))
                return false;       
        }           
        else if (this[i] != array[i]) { 
            // Warning - two different object instances will never be equal: {x:20} != {x:20}
            return false;   
        }           
    }       
    return true;
}
// Hide method from for-in loops
Object.defineProperty(Array.prototype, "equals", {enumerable: false});

Sử dụng:

[1, 2, [3, 4]].equals([1, 2, [3, 2]]) === false;
[1, "2,3"].equals([1, 2, 3]) === false;
[1, 2, [3, 4]].equals([1, 2, [3, 4]]) === true;
[1, 2, 1, 2].equals([1, 2, 1, 2]) === true;

Bạn có thể nói " Nhưng nhanh hơn nhiều so với các chuỗi - không có vòng lặp ... ", thì bạn nên lưu ý có các vòng lặp. Vòng lặp đệ quy đầu tiên chuyển đổi Array thành chuỗi và thứ hai, so sánh hai chuỗi. Vì vậy, phương pháp này nhanh hơn sử dụng chuỗi .

_{Tôi tin rằng lượng dữ liệu lớn hơn phải luôn được lưu trữ trong mảng chứ không phải trong các đối tượng. Tuy nhiên nếu bạn sử dụng các đối tượng, chúng cũng có thể được so sánh một phần.
Đây là cách thực hiện:}

Đối tượng so sánh:

Tôi đã nói ở trên, hai trường hợp đối tượng sẽ không bao giờ bằng nhau, ngay cả khi chúng chứa cùng một dữ liệu tại thời điểm này:

({a:1, foo:"bar", numberOfTheBeast: 666}) == ({a:1, foo:"bar", numberOfTheBeast: 666})  //false

Điều này có một lý do, vì có thể có, ví dụ các biến riêng tư trong các đối tượng.

Tuy nhiên, nếu bạn chỉ sử dụng cấu trúc đối tượng để chứa dữ liệu, vẫn có thể so sánh:

Object.prototype.equals = function(object2) {
    //For the first loop, we only check for types
    for (propName in this) {
        //Check for inherited methods and properties - like .equals itself
        //https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty
        //Return false if the return value is different
        if (this.hasOwnProperty(propName) != object2.hasOwnProperty(propName)) {
            return false;
        }
        //Check instance type
        else if (typeof this[propName] != typeof object2[propName]) {
            //Different types => not equal
            return false;
        }
    }
    //Now a deeper check using other objects property names
    for(propName in object2) {
        //We must check instances anyway, there may be a property that only exists in object2
            //I wonder, if remembering the checked values from the first loop would be faster or not 
        if (this.hasOwnProperty(propName) != object2.hasOwnProperty(propName)) {
            return false;
        }
        else if (typeof this[propName] != typeof object2[propName]) {
            return false;
        }
        //If the property is inherited, do not check any more (it must be equa if both objects inherit it)
        if(!this.hasOwnProperty(propName))
          continue;

        //Now the detail check and recursion

        //This returns the script back to the array comparing
        /**REQUIRES Array.equals**/
        if (this[propName] instanceof Array && object2[propName] instanceof Array) {
                   // recurse into the nested arrays
           if (!this[propName].equals(object2[propName]))
                        return false;
        }
        else if (this[propName] instanceof Object && object2[propName] instanceof Object) {
                   // recurse into another objects
                   //console.log("Recursing to compare ", this[propName],"with",object2[propName], " both named \""+propName+"\"");
           if (!this[propName].equals(object2[propName]))
                        return false;
        }
        //Normal value comparison for strings and numbers
        else if(this[propName] != object2[propName]) {
           return false;
        }
    }
    //If everything passed, let's say YES
    return true;
}  

Tuy nhiên, hãy nhớ rằng cái này là để phục vụ trong việc so sánh JSON như dữ liệu, không phải các thể hiện lớp và các thứ khác. Nếu bạn muốn so sánh các đối tượng phức tạp mor, hãy xem câu trả lời này và đó là chức năng siêu dài .
Để thực hiện công việc này với Array.equalsbạn, bạn phải chỉnh sửa chức năng ban đầu một chút:

...
    // Check if we have nested arrays
    if (this[i] instanceof Array && array[i] instanceof Array) {
        // recurse into the nested arrays
        if (!this[i].equals(array[i]))
            return false;
    }
    /**REQUIRES OBJECT COMPARE**/
    else if (this[i] instanceof Object && array[i] instanceof Object) {
        // recurse into another objects
        //console.log("Recursing to compare ", this[propName],"with",object2[propName], " both named \""+propName+"\"");
        if (!this[i].equals(array[i]))
            return false;
        }
    else if (this[i] != array[i]) {
...

Tôi đã tạo ra một công cụ kiểm tra nhỏ cho cả hai chức năng .

Phần thưởng: Mảng lồng nhau với indexOfvàcontains

Samy Bencherif đã chuẩn bị các chức năng hữu ích cho trường hợp bạn đang tìm kiếm một đối tượng cụ thể trong các mảng lồng nhau, có sẵn ở đây: https://jsfiddle.net/SamyBencherif/8352y6yw/

Mặc dù điều này chỉ hoạt động cho các mảng vô hướng (xem ghi chú bên dưới), nhưng nó ngắn:

array1.length === array2.length && array1.every(function(value, index) { return value === array2[index]})

Rr, trong ECMAScript 6 / CoffeeScript / TypeScript với các hàm mũi tên:

array1.length === array2.length && array1.every((value, index) => value === array2[index])

(Lưu ý: 'vô hướng' ở đây có nghĩa là các giá trị có thể được so sánh trực tiếp bằng cách sử dụng ===. Vì vậy: số, chuỗi, đối tượng theo tham chiếu, hàm theo tham chiếu. Xem tham chiếu MDN để biết thêm thông tin về toán tử so sánh).

CẬP NHẬT

Từ những gì tôi đọc được từ các bình luận, sắp xếp mảng và so sánh có thể cho kết quả chính xác:

array1.length === array2.length && array1.sort().every(function(value, index) { return value === array2.sort()[index]});

Ví dụ:

array1 = [2,3,1,4];
array2 = [1,2,3,4];

Sau đó, mã trên sẽ cung cấp cho true

Tôi thích sử dụng thư viện Underscore cho các dự án mã hóa mảng / đối tượng nặng ... trong Underscore và Lodash cho dù bạn đang so sánh các mảng hoặc các đối tượng giống như thế này:

_.isEqual(array1, array2)   // returns a boolean
_.isEqual(object1, object2) // returns a boolean

• Underscore isEqual docs
• Tài liệu tạm thời

Tôi nghĩ đây là cách đơn giản nhất để thực hiện bằng cách sử dụng JSON Stringify và nó có thể là giải pháp tốt nhất trong một số trường hợp:

JSON.stringify(a1) === JSON.stringify(a2);

Điều này chuyển đổi các đối tượng a1và a2thành chuỗi để chúng có thể được so sánh. Thứ tự này rất quan trọng trong hầu hết các trường hợp, vì điều đó có thể sắp xếp đối tượng bằng thuật toán sắp xếp được hiển thị trong một trong các câu trả lời ở trên.

Xin lưu ý rằng bạn không còn so sánh đối tượng mà là biểu diễn chuỗi của đối tượng. Nó có thể không chính xác những gì bạn muốn.

Không rõ ý của bạn là "giống hệt". Ví dụ, các mảng avà bbên dưới có giống nhau không (lưu ý các mảng lồng nhau)?

var a = ["foo", ["bar"]], b = ["foo", ["bar"]];

Đây là một hàm so sánh mảng được tối ưu hóa, lần lượt so sánh các phần tử tương ứng của từng mảng bằng cách sử dụng đẳng thức nghiêm ngặt và không so sánh đệ quy các phần tử mảng mà chính chúng là mảng, có nghĩa là ví dụ trên arraysIdentical(a, b)sẽ trả về false. Nó hoạt động trong trường hợp chung, mà join()các giải pháp dựa trên JSON và sẽ không:

function arraysIdentical(a, b) {
    var i = a.length;
    if (i != b.length) return false;
    while (i--) {
        if (a[i] !== b[i]) return false;
    }
    return true;
};

Cách thực hành

Tôi nghĩ thật sai lầm khi nói một triển khai cụ thể là "Đúng cách ™" nếu chỉ "đúng" ("đúng") trái ngược với giải pháp "sai". Giải pháp của Tomáš là một cải tiến rõ ràng so với so sánh mảng dựa trên chuỗi, nhưng điều đó không có nghĩa là nó "đúng" một cách khách quan. Điều gì là đúng ? Có phải là nhanh nhất? Nó có linh hoạt nhất không? Là nó dễ hiểu nhất? Đây có phải là cách nhanh nhất để gỡ lỗi? Nó sử dụng ít hoạt động nhất? Nó có bất kỳ tác dụng phụ? Không một giải pháp nào có thể có thứ tốt nhất trong tất cả mọi thứ.

Tomáš có thể nói giải pháp của anh ấy rất nhanh nhưng tôi cũng sẽ nói rằng nó rất phức tạp. Nó cố gắng trở thành một giải pháp tất cả trong một, hoạt động cho tất cả các mảng, lồng nhau hoặc không. Trên thực tế, nó thậm chí còn chấp nhận nhiều hơn là các mảng như một đầu vào và vẫn cố gắng đưa ra câu trả lời "hợp lệ".

Generics cung cấp tái sử dụng

Câu trả lời của tôi sẽ tiếp cận vấn đề khác nhau. Tôi sẽ bắt đầu với một arrayComparethủ tục chung chỉ liên quan đến việc bước qua các mảng. Từ đó, chúng tôi sẽ xây dựng chức năng so sánh cơ bản khác của chúng tôi như arrayEqualvà arrayDeepEqual, vv

// arrayCompare :: (a -> a -> Bool) -> [a] -> [a] -> Bool
const arrayCompare = f => ([x,...xs]) => ([y,...ys]) =>
  x === undefined && y === undefined
    ? true
    : Boolean (f (x) (y)) && arrayCompare (f) (xs) (ys)

Theo tôi, loại mã tốt nhất thậm chí không cần bình luận, và điều này cũng không ngoại lệ. Có quá ít xảy ra ở đây mà bạn có thể hiểu hành vi của thủ tục này mà hầu như không có nỗ lực nào cả. Chắc chắn, một số cú pháp ES6 có vẻ xa lạ với bạn bây giờ, nhưng đó chỉ là do ES6 còn khá mới.

Như kiểu gợi ý, arrayComparecó chức năng so sánh f, và hai mảng đầu vào, xsvà ys. Đối với hầu hết các phần, tất cả những gì chúng ta làm là gọi f (x) (y)cho từng phần tử trong mảng đầu vào. Chúng tôi trở lại một đầu falsenếu người dùng xác định flợi nhuận false- nhờ &&'s đánh giá ngắn mạch. Vì vậy, có, điều này có nghĩa là bộ so sánh có thể dừng lặp lại sớm và ngăn chặn việc lặp qua phần còn lại của mảng đầu vào khi không cần thiết.

So sánh nghiêm ngặt

Tiếp theo, sử dụng arrayComparechức năng của chúng tôi , chúng tôi có thể dễ dàng tạo các chức năng khác mà chúng tôi có thể cần. Chúng tôi sẽ bắt đầu với tiểu arrayEqual...

// equal :: a -> a -> Bool
const equal = x => y =>
  x === y // notice: triple equal

// arrayEqual :: [a] -> [a] -> Bool
const arrayEqual =
  arrayCompare (equal)

const xs = [1,2,3]
const ys = [1,2,3]
console.log (arrayEqual (xs) (ys))      //=> true
// (1 === 1) && (2 === 2) && (3 === 3)  //=> true

const zs = ['1','2','3']
console.log (arrayEqual (xs) (zs))      //=> false
// (1 === '1')                          //=> false

Đơn giản như thế. arrayEqualcó thể được định nghĩa với arrayComparevà một hàm so sánh so sánh avới bviệc sử dụng ===(đối với đẳng thức nghiêm ngặt).

Lưu ý rằng chúng tôi cũng định nghĩa equallà chức năng riêng của nó. Điều này nhấn mạnh vai trò của arrayComparemột hàm bậc cao hơn để sử dụng bộ so sánh thứ tự đầu tiên của chúng tôi trong bối cảnh của một loại dữ liệu khác (Mảng).

So sánh lỏng lẻo

Chúng ta có thể dễ dàng xác định arrayLooseEqualbằng cách sử dụng ==thay thế. Bây giờ khi so sánh 1(Số) để '1'(String), kết quả sẽ là true...

// looseEqual :: a -> a -> Bool
const looseEqual = x => y =>
  x == y // notice: double equal

// arrayLooseEqual :: [a] -> [a] -> Bool
const arrayLooseEqual =
  arrayCompare (looseEqual)

const xs = [1,2,3]
const ys = ['1','2','3']
console.log (arrayLooseEqual (xs) (ys))    //=> true
// (1 == '1') && (2 == '2') && (3 == '3')  //=> true

So sánh sâu (đệ quy)

Bạn có thể nhận thấy rằng đây chỉ là so sánh nông. Chắc chắn giải pháp của Tomáš là "The Right Way ™" bởi vì nó ngầm ẩn sự so sánh sâu sắc, phải không?

Chà, arrayComparethủ tục của chúng tôi đủ linh hoạt để sử dụng theo cách làm cho một bài kiểm tra công bằng sâu sắc trở nên dễ dàng

// isArray :: a -> Bool
const isArray =
  Array.isArray

// arrayDeepCompare :: (a -> a -> Bool) -> [a] -> [a] -> Bool
const arrayDeepCompare = f =>
  arrayCompare (a => b =>
    isArray (a) && isArray (b)
      ? arrayDeepCompare (f) (a) (b)
      : f (a) (b))

const xs = [1,[2,[3]]]
const ys = [1,[2,['3']]]
console.log (arrayDeepCompare (equal) (xs) (ys)) //=> false
// (1 === 1) && (2 === 2) && (3 === '3')         //=> false

console.log (arrayDeepCompare (looseEqual) (xs) (ys)) //=> true
// (1 == 1) && (2 == 2) && (3 == '3')                 //=> true

Đơn giản như thế. Chúng tôi xây dựng một bộ so sánh sâu bằng cách sử dụng chức năng bậc cao khác . Lần này chúng tôi sẽ arrayComparesử dụng một bộ so sánh tùy chỉnh sẽ kiểm tra xem avà bcó phải là mảng không. Nếu vậy, hãy áp dụng lại arrayDeepCompareso sánh avà so sánh với bộ so sánh bdo người dùng chỉ định ( f). Điều này cho phép chúng tôi giữ hành vi so sánh sâu tách biệt với cách chúng tôi thực sự so sánh các yếu tố riêng lẻ. Ví dụ, như ví dụ trên cho thấy, chúng ta có thể so sánh sâu sử dụng equal, looseEqualhoặc bất kỳ so sánh khác mà chúng tôi thực hiện.

Vì arrayDeepComparebị chế giễu, chúng ta có thể áp dụng một phần như trong các ví dụ trước

// arrayDeepEqual :: [a] -> [a] -> Bool
const arrayDeepEqual =
  arrayDeepCompare (equal)

// arrayDeepLooseEqual :: [a] -> [a] -> Bool
const arrayDeepLooseEqual =
  arrayDeepCompare (looseEqual)

Đối với tôi, đây đã là một cải tiến rõ ràng so với giải pháp của Tomáš vì tôi rõ ràng có thể chọn một so sánh nông hoặc sâu cho các mảng của mình, khi cần.

So sánh đối tượng (ví dụ)

Bây giờ nếu bạn có một mảng các đối tượng hoặc một cái gì đó thì sao? Có lẽ bạn muốn coi các mảng đó là "bằng nhau" nếu mỗi đối tượng có cùng idgiá trị

// idEqual :: {id: Number} -> {id: Number} -> Bool
const idEqual = x => y =>
  x.id !== undefined && x.id === y.id

// arrayIdEqual :: [a] -> [a] -> Bool
const arrayIdEqual =
  arrayCompare (idEqual)

const xs = [{id:1}, {id:2}]
const ys = [{id:1}, {id:2}]
console.log (arrayIdEqual (xs) (ys)) //=> true
// (1 === 1) && (2 === 2)            //=> true

const zs = [{id:1}, {id:6}]
console.log (arrayIdEqual (xs) (zs)) //=> false
// (1 === 1) && (2 === 6)            //=> false

Đơn giản như thế. Ở đây tôi đã sử dụng các đối tượng JS vanilla, nhưng loại so sánh này có thể hoạt động cho bất kỳ loại đối tượng nào ; thậm chí các đối tượng tùy chỉnh của bạn. Giải pháp của Tomáš sẽ cần phải được làm lại hoàn toàn để hỗ trợ loại thử nghiệm bình đẳng này

Mảng sâu với các đối tượng? Không thành vấn đề. Chúng tôi đã xây dựng các chức năng chung, linh hoạt cao, vì vậy chúng sẽ hoạt động trong nhiều trường hợp sử dụng khác nhau.

const xs = [{id:1}, [{id:2}]]
const ys = [{id:1}, [{id:2}]]
console.log (arrayCompare (idEqual) (xs) (ys))     //=> false
console.log (arrayDeepCompare (idEqual) (xs) (ys)) //=> true

So sánh tùy tiện (ví dụ)

Hoặc nếu bạn muốn làm một số loại so sánh hoàn toàn tùy ý khác thì sao? Có lẽ tôi muốn biết nếu mỗi cái xlớn hơn mỗi tên ylửa

// gt :: Number -> Number -> Bool
const gt = x => y =>
  x > y

// arrayGt :: [a] -> [a] -> Bool
const arrayGt = arrayCompare (gt)

const xs = [5,10,20]
const ys = [2,4,8]
console.log (arrayGt (xs) (ys))     //=> true
// (5 > 2) && (10 > 4) && (20 > 8)  //=> true

const zs = [6,12,24]
console.log (arrayGt (xs) (zs))     //=> false
// (5 > 6)                          //=> false

Càng đơn giản càng đẹp

Bạn có thể thấy chúng tôi thực sự đang làm nhiều hơn với ít mã hơn. Không có gì phức tạp về arrayComparebản thân và mỗi bộ so sánh tùy chỉnh chúng tôi đã thực hiện có một cách thực hiện rất đơn giản.

Để dễ dàng, chúng ta có thể xác định chính xác cách chúng ta muốn so sánh hai mảng - nông, sâu, nghiêm ngặt, lỏng lẻo, một số thuộc tính đối tượng hoặc một số tính toán tùy ý hoặc bất kỳ kết hợp nào của các mảng - tất cả đều sử dụng một thủ tục , arrayCompare. Thậm chí có thể mơ lên ​​một RegExpso sánh! Tôi biết trẻ em thích những trò regexps như thế nào

Có phải là nhanh nhất? Không. Nhưng nó có lẽ không cần phải là một trong hai. Nếu tốc độ là chỉ số duy nhất được sử dụng để đo lường chất lượng mã của chúng tôi, thì rất nhiều mã thực sự tuyệt vời sẽ bị loại bỏ - Đó là lý do tại sao tôi gọi phương pháp này là Cách thực tế . Hoặc có thể để công bằng hơn, Một cách thực tế. Mô tả này phù hợp với câu trả lời này vì tôi không nói câu trả lời này chỉ thực tế so với một số câu trả lời khác; nó là khách quan đúng Chúng tôi đã đạt được mức độ thực tiễn cao với rất ít mã rất dễ lý do. Không có mã nào khác có thể nói chúng tôi chưa kiếm được mô tả này.

Điều đó làm cho nó là giải pháp "đúng" cho bạn? Đó là do bạn quyết định. Và không ai khác có thể làm điều đó cho bạn; chỉ có bạn biết nhu cầu của bạn là gì. Trong hầu hết các trường hợp, tôi đánh giá mã đơn giản, thực tế và linh hoạt hơn loại thông minh và nhanh chóng. Những gì bạn đánh giá có thể khác nhau, vì vậy hãy chọn những gì phù hợp với bạn.

Biên tập

Câu trả lời cũ của tôi tập trung hơn vào việc phân rã arrayEqualthành các thủ tục nhỏ. Đây là một bài tập thú vị, nhưng không thực sự là cách tốt nhất (thực tế nhất) để tiếp cận vấn đề này. Nếu bạn quan tâm, bạn có thể xem lịch sử sửa đổi này.

Theo tinh thần của câu hỏi ban đầu:

Tôi muốn so sánh hai mảng ... lý tưởng, hiệu quả . Không có gì lạ mắt , chỉ đúng nếu chúng giống hệt nhau, và sai nếu không.

Tôi đã chạy thử nghiệm hiệu suất trên một số đề xuất đơn giản hơn được đề xuất ở đây với các kết quả sau (nhanh đến chậm):

trong khi (67%) bởi Tim Down

var i = a1.length;
while (i--) {
    if (a1[i] !== a2[i]) return false;
}
return true

mỗi (69%) bởi người dùng2782196

a1.every((v,i)=> v === a2[i]);

giảm (74%) bởi DEI

a1.reduce((a, b) => a && a2.includes(b), true);

tham gia & toString (78%) bởi Gaizka Allende & vivek

a1.join('') === a2.join('');

a1.toString() === a2.toString();

một nửa toString (90%) của Victor Palomo

a1 == a2.toString();

stringify (100%) bởi radtek

JSON.stringify(a1) === JSON.stringify(a2);

Lưu ý các ví dụ dưới đây giả định các mảng được sắp xếp, mảng một chiều. .lengthso sánh đã bị xóa đối với điểm chuẩn chung (thêm a1.length === a2.lengthvào bất kỳ đề xuất nào và bạn sẽ được tăng hiệu suất ~ 10%). Chọn bất kỳ giải pháp nào phù hợp nhất với bạn để biết tốc độ và giới hạn của từng giải pháp.

Lưu ý không liên quan: thật thú vị khi thấy mọi người nhận được tất cả John Waynes vui vẻ trên nút bỏ phiếu về câu trả lời hoàn toàn hợp pháp cho câu hỏi này.

Dựa trên câu trả lời của Tomáš Zato, tôi đồng ý rằng chỉ cần lặp qua các mảng là nhanh nhất. Ngoài ra (như những người khác đã nêu), hàm nên được gọi là bằng / bằng, không so sánh. Để giải quyết vấn đề này, tôi đã sửa đổi chức năng để xử lý việc so sánh các mảng cho sự tương đồng - tức là chúng có cùng các yếu tố, nhưng không theo thứ tự - để sử dụng cá nhân, và nghĩ rằng tôi sẽ ném nó vào đây cho mọi người xem.

Array.prototype.equals = function (array, strict) {
    if (!array)
        return false;

    if (arguments.length == 1)
        strict = true;

    if (this.length != array.length)
        return false;

    for (var i = 0; i < this.length; i++) {
        if (this[i] instanceof Array && array[i] instanceof Array) {
            if (!this[i].equals(array[i], strict))
                return false;
        }
        else if (strict && this[i] != array[i]) {
            return false;
        }
        else if (!strict) {
            return this.sort().equals(array.sort(), true);
        }
    }
    return true;
}

Hàm này có một tham số bổ sung nghiêm ngặt mặc định là true. Tham số nghiêm ngặt này xác định nếu các mảng cần phải hoàn toàn bằng nhau về cả nội dung và thứ tự của các nội dung đó, hoặc chỉ đơn giản là chứa cùng một nội dung.

Thí dụ:

var arr1 = [1, 2, 3, 4];
var arr2 = [2, 1, 4, 3];  // Loosely equal to 1
var arr3 = [2, 2, 3, 4];  // Not equal to 1
var arr4 = [1, 2, 3, 4];  // Strictly equal to 1

arr1.equals(arr2);         // false
arr1.equals(arr2, false);  // true
arr1.equals(arr3);         // false
arr1.equals(arr3, false);  // false
arr1.equals(arr4);         // true
arr1.equals(arr4, false);  // true

Tôi cũng đã viết lên một jsfiddle nhanh chóng với chức năng và ví dụ này:
http://jsfiddle.net/Roundaround/DLkxX/

Mặc dù điều này có rất nhiều câu trả lời, nhưng câu trả lời mà tôi tin là có ích:

const newArray = [ ...new Set( [...arr1, ...arr2] ) ]

Nó không được nêu trong câu hỏi cấu trúc của mảng sẽ trông như thế nào, vì vậy Nếu bạn biết chắc chắn rằng bạn sẽ không có các mảng lồng nhau cũng như các đối tượng trong mảng của bạn (nó đã xảy ra với tôi, đó là lý do tại sao tôi đến với điều này Trả lời) đoạn mã trên sẽ hoạt động.

Điều gì xảy ra là chúng tôi sử dụng toán tử trải (...) để nối cả hai mảng, sau đó chúng tôi sử dụng Set để loại bỏ mọi trùng lặp. Một khi bạn có điều đó, bạn có thể so sánh kích thước của chúng, nếu cả ba mảng có cùng kích thước, bạn đều có thể đi.

Câu trả lời này cũng bỏ qua thứ tự các yếu tố , như tôi đã nói, tình huống chính xác đã xảy ra với tôi, vì vậy có lẽ ai đó trong tình huống tương tự có thể kết thúc ở đây (như tôi đã làm).

Chỉnh sửa1.

Trả lời câu hỏi của Dmitry Grinko: "Tại sao bạn sử dụng toán tử lây lan (...) tại đây - ... Bộ mới? Nó không hoạt động"

Xem xét mã này:

const arr1 = [ 'a', 'b' ]
const arr2 = [ 'a', 'b', 'c' ]
const newArray = [ new Set( [...arr1, ...arr2] ) ]
console.log(newArray)

Bạn sẽ nhận được

[ Set { 'a', 'b', 'c' } ]

Để làm việc với giá trị đó, bạn cần sử dụng một số thuộc tính Set (xem https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/set ). Mặt khác, khi bạn sử dụng mã này:

const arr1 = [ 'a', 'b' ]
const arr2 = [ 'a', 'b', 'c' ]
const newArray = [ ...new Set( [...arr1, ...arr2] ) ]
console.log(newArray)

Bạn sẽ nhận được

[ 'a', 'b', 'c' ]

Đó là sự khác biệt, cái trước sẽ cho tôi một Bộ, nó cũng hoạt động vì tôi có thể lấy kích thước của Bộ đó, nhưng cái sau cho tôi mảng tôi cần, những gì trực tiếp hơn với độ phân giải.

Trên cùng một dòng với JSON.encode là sử dụng phép nối ().

function checkArrays( arrA, arrB ){

    //check if lengths are different
    if(arrA.length !== arrB.length) return false;


    //slice so we do not effect the original
    //sort makes sure they are in order
    //join makes it a string so we can do a string compare
    var cA = arrA.slice().sort().join(","); 
    var cB = arrB.slice().sort().join(",");

    return cA===cB;

}

var a = [1,2,3,4,5];
var b = [5,4,3,2,1];
var c = [1,2,3,4];
var d = [1,2,3,4,6];
var e = ["1","2","3","4","5"];  //will return true

console.log( checkArrays(a,b) );  //true
console.log( checkArrays(a,c) );  //false
console.log( checkArrays(a,d) );  //false
console.log( checkArrays(a,e) );  //true

Vấn đề duy nhất là nếu bạn quan tâm đến các loại kiểm tra so sánh cuối cùng. Nếu bạn quan tâm về các loại, bạn sẽ phải lặp.

function checkArrays( arrA, arrB ){

    //check if lengths are different
    if(arrA.length !== arrB.length) return false;

    //slice so we do not effect the orginal
    //sort makes sure they are in order
    var cA = arrA.slice().sort(); 
    var cB = arrB.slice().sort();

    for(var i=0;i<cA.length;i++){
         if(cA[i]!==cB[i]) return false;
    }

    return true;

}

var a = [1,2,3,4,5];
var b = [5,4,3,2,1];
var c = [1,2,3,4];
var d = [1,2,3,4,6];
var e = ["1","2","3","4","5"];

console.log( checkArrays(a,b) );  //true
console.log( checkArrays(a,c) );  //false
console.log( checkArrays(a,d) );  //false
console.log( checkArrays(a,e) );  //false

Nếu thứ tự nên giữ nguyên, vì nó chỉ là một vòng lặp, không cần sắp xếp.

function checkArrays( arrA, arrB ){

    //check if lengths are different
    if(arrA.length !== arrB.length) return false;


    for(var i=0;i<arrA.length;i++){
         if(arrA[i]!==arrB[i]) return false;
    }

    return true;

}

var a = [1,2,3,4,5];
var b = [5,4,3,2,1];
var c = [1,2,3,4];
var d = [1,2,3,4,6];
var e = ["1","2","3","4","5"];

console.log( checkArrays(a,a) );  //true
console.log( checkArrays(a,b) );  //false
console.log( checkArrays(a,c) );  //false
console.log( checkArrays(a,d) );  //false
console.log( checkArrays(a,e) );  //false

Đây là phiên bản Bản in:

//https://stackoverflow.com/a/16436975/2589276
export function arraysEqual<T>(a: Array<T>, b: Array<T>): boolean {
    if (a === b) return true
    if (a == null || b == null) return false
    if (a.length != b.length) return false

    for (var i = 0; i < a.length; ++i) {
        if (a[i] !== b[i]) return false
    }
    return true
}

//https://stackoverflow.com/a/16436975/2589276
export function arraysDeepEqual<T>(a: Array<T>, b: Array<T>): boolean {
    return JSON.stringify(a) === JSON.stringify(b)
}

Một số trường hợp thử nghiệm cho mocha:

it('arraysEqual', function () {
    let a = [1,2]
    let b = [1,2]
    let c = [2,3]
    let d = [2, 3]
    let e = ['car','apple','banana']
    let f = ['car','apple','banana']
    let g = ['car','apple','banan8']

    expect(arraysEqual(a, b)).to.equal(true)
    expect(arraysEqual(c, d)).to.equal(true)
    expect(arraysEqual(a, d)).to.equal(false)
    expect(arraysEqual(e, f)).to.equal(true)
    expect(arraysEqual(f, g)).to.equal(false)
})

it('arraysDeepEqual', function () {
    let a = [1,2]
    let b = [1,2]
    let c = [2,3]
    let d = [2, 3]
    let e = ['car','apple','banana']
    let f = ['car','apple','banana']
    let g = ['car','apple','banan8']
    let h = [[1,2],'apple','banan8']
    let i = [[1,2],'apple','banan8']
    let j = [[1,3],'apple','banan8']

    expect(arraysDeepEqual(a, b)).to.equal(true)
    expect(arraysDeepEqual(c, d)).to.equal(true)
    expect(arraysDeepEqual(a, d)).to.equal(false)
    expect(arraysDeepEqual(e, f)).to.equal(true)
    expect(arraysDeepEqual(f, g)).to.equal(false)
    expect(arraysDeepEqual(h, i)).to.equal(true)
    expect(arraysDeepEqual(h, j)).to.equal(false)
})

Nếu bạn đang sử dụng khung kiểm tra như Mocha với thư viện xác nhận Chai , bạn có thể sử dụng đẳng thức sâu để so sánh các mảng.

expect(a1).to.deep.equal(a2)

Điều này sẽ trả về true chỉ khi các mảng có các phần tử bằng nhau tại các chỉ số tương ứng.

Nếu chúng chỉ là hai mảng số hoặc chuỗi, thì đây là một dòng một dòng nhanh

const array1 = [1, 2, 3];
const array2 = [1, 3, 4];
console.log(array1.join(',') === array2.join(',')) //false

const array3 = [1, 2, 3];
const array4 = [1, 2, 3];
console.log(array3.join(',') === array4.join(',')) //true

Trong trường hợp của tôi, mảng so sánh chỉ chứa số và chuỗi. Hàm này sẽ hiển thị cho bạn nếu mảng chứa các phần tử giống nhau.

function are_arrs_match(arr1, arr2){
    return arr1.sort().toString() === arr2.sort().toString()
}

Hãy thử nghiệm nó!

arr1 = [1, 2, 3, 'nik']
arr2 = ['nik', 3, 1, 2]
arr3 = [1, 2, 5]

console.log (are_arrs_match(arr1, arr2)) //true
console.log (are_arrs_match(arr1, arr3)) //false

Điều này so sánh 2 mảng chưa được sắp xếp:

function areEqual(a, b) {
  if ( a.length != b.length) {
    return false;
  }
  return a.filter(function(i) {
    return !b.includes(i);
  }).length === 0;  
}

Đối với một dãy số hãy thử:

a1==''+a2

var a1 = [1,2,3];
var a2 = [1,2,3];

console.log( a1==''+a2 )

Lưu ý: phương thức này sẽ không hoạt động khi mảng cũng chứa các chuỗi, vd a2 = [1, "2,3"].

Chúng tôi có thể thực hiện việc này theo cách chức năng, bằng cách sử dụng every( https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/every )

function compareArrays(array1, array2) {
    if (array1.length === array2.length)
        return array1.every((a, index) => a === array2[index])
    else
        return false
}

// test
var a1 = [1,2,3];
var a2 = [1,2,3];

var a3 = ['a', 'r', 'r', 'a', 'y', '1']
var a4 = ['a', 'r', 'r', 'a', 'y', '2']

console.log(compareArrays(a1,a2)) // true
console.log(compareArrays(a1,a3)) // false
console.log(compareArrays(a3,a4)) // false

Mã của bạn sẽ không xử lý trường hợp một cách thích hợp khi cả hai mảng có cùng các phần tử nhưng không theo cùng một thứ tự.

Hãy xem mã của tôi với ví dụ của bạn để so sánh hai mảng có các phần tử là số, bạn có thể sửa đổi hoặc mở rộng nó cho các loại phần tử khác (bằng cách sử dụng .join () thay vì .toString ()).

var a1 = [1,2,3];
var a2 = [1,2,3];
const arraysAreEqual = a1.sort().toString()==a2.sort().toString();
// true if both arrays have same elements else false
console.log(arraysAreEqual);

Giải pháp của Herer:

/**
 * Tests two data structures for equality
 * @param {object} x
 * @param {object} y
 * @returns {boolean}
 */
var equal = function(x, y) {
    if (typeof x !== typeof y) return false;
    if (x instanceof Array && y instanceof Array && x.length !== y.length) return false;
    if (typeof x === 'object') {
        for (var p in x) if (x.hasOwnProperty(p)) {
            if (typeof x[p] === 'function' && typeof y[p] === 'function') continue;
            if (x[p] instanceof Array && y[p] instanceof Array && x[p].length !== y[p].length) return false;
            if (typeof x[p] !== typeof y[p]) return false;
            if (typeof x[p] === 'object' && typeof y[p] === 'object') { if (!equal(x[p], y[p])) return false; } else
            if (x[p] !== y[p]) return false;
        }
    } else return x === y;
    return true;
};

Hoạt động với bất kỳ cấu trúc dữ liệu lồng nhau nào và rõ ràng bỏ qua các phương thức của đối tượng. Thậm chí đừng nghĩ đến việc mở rộng Object.prototype bằng phương thức này, khi tôi đã thử điều này một lần, jQuery đã bị hỏng;)

Đối với hầu hết các mảng, nó vẫn nhanh hơn hầu hết các giải pháp tuần tự hóa. Đây có lẽ là phương pháp so sánh nhanh nhất cho các mảng của các bản ghi đối tượng.

JSON.stringify(collectionNames).includes(JSON.stringify(sourceNames)) ?  array.push(collection[i]) : null

Đây là cách tôi đã làm nó.

So sánh 2 mảng:

var arr1 = [1,2,3];
var arr2 = [1,2,3];

function compare(arr1,arr2)
{
  if((arr1 == arr2) && (arr1.length == arr2.length))
    return true;
  else
    return false;
}

chức năng gọi

var isBool = compare(arr1.sort().join(),arr2.sort().join());

Tôi tin vào đồng bằng JSvà với ECMAScript 2015, đó là ngọt ngào và đơn giản để hiểu.

var is_arrays_compare_similar = function (array1, array2) {

    let flag = true;

    if (array1.length == array2.length) {

        // check first array1 object is available in array2 index
        array1.every( array_obj => {
            if (flag) {
                if (!array2.includes(array_obj)) {
                    flag = false;
                }
            }
        });

        // then vice versa check array2 object is available in array1 index
        array2.every( array_obj => {
            if (flag) {
                if (!array1.includes(array_obj)) {
                    flag = false;
                }
            }
        });

        return flag;
    } else {
        return false;
    }

}

hy vọng nó sẽ giúp được ai đó

Mở rộng ý tưởng Tomáš Zato. Array'spr.prototype.compare của Tomas phải được gọi là Array.prototype.compareIdentical.

Nó truyền lại:

[1, 2, [3, 4]].compareIdentical ([1, 2, [3, 2]]) === false;
[1, "2,3"].compareIdentical ([1, 2, 3]) === false;
[1, 2, [3, 4]].compareIdentical ([1, 2, [3, 4]]) === true;
[1, 2, 1, 2].compareIdentical ([1, 2, 1, 2]) === true;

Nhưng thất bại về:

[[1, 2, [3, 2]],1, 2, [3, 2]].compareIdentical([1, 2, [3, 2],[1, 2, [3, 2]]])

Đây là phiên bản tốt hơn (theo ý kiến ​​của tôi):

Array.prototype.compare = function (array) {
    // if the other array is a falsy value, return
    if (!array)
        return false;

    // compare lengths - can save a lot of time
    if (this.length != array.length)
        return false;

    this.sort();
    array.sort();
    for (var i = 0; i < this.length; i++) {
        // Check if we have nested arrays
        if (this[i] instanceof Array && array[i] instanceof Array) {
            // recurse into the nested arrays
            if (!this[i].compare(array[i]))
                return false;
        }
        else if (this[i] != array[i]) {
            // Warning - two different object instances will never be equal: {x:20} != {x:20}
            return false;
        }
    }
    return true;
}

http://jsfiddle.net/igos/bcfCY/

var a1 = [1,2,3,6];
var a2 = [1,2,3,5];

function check(a, b) {
  return (a.length != b.length) ? false : 
  a.every(function(row, index) {
    return a[index] == b[index];
  });
}  

check(a1, a2);

////// HOẶC LÀ ///////

var a1 = [1,2,3,6];
var a2 = [1,2,3,6];

function check(a, b) {
  return (a.length != b.length) ? false : 
  !(a.some(function(row, index) {
    return a[index] != b[index];
  }));
}  

check(a1, a2)

Một cách tiếp cận khác với rất ít mã (sử dụng Array giảm và Array bao gồm ):

arr1.length == arr2.length && arr1.reduce((a, b) => a && arr2.includes(b), true)

Nếu bạn muốn so sánh sự bình đẳng của trật tự:

arr1.length == arr2.length && arr1.reduce((a, b, i) => a && arr2[i], true)

• Các lengthĐảm bảo kiểm tra rằng tập các phần tử trong một mảng không chỉ là một tập hợp con của một trong những khác.

• Bộ giảm tốc được sử dụng để đi qua một mảng và tìm kiếm từng mục trong mảng khác. Nếu một mục không được tìm thấy, hàm return trả về false.

  1. Trong ví dụ đầu tiên, nó đã được kiểm tra rằng một yếu tố được bao gồm
  2. Ví dụ thứ hai cũng kiểm tra thứ tự

Một cách tiếp cận đơn giản:

function equals(a, b) {
    if ((a && !b) || (!a && b) || (!a && !b) || (a.length !== b.length)) {
        return false;
    }

    var isDifferent = a.some(function (element, index) { 
        return element !== b[index];
    });

    return !isDifferent;
}

Đã có một số câu trả lời tuyệt vời. Nhưng tôi muốn chia sẻ ý tưởng bao phấn đã được chứng minh là đáng tin cậy trong việc so sánh các mảng. Chúng ta có thể so sánh hai mảng bằng JSON.opesify () . Nó sẽ tạo ra một chuỗi ra khỏi mảng và do đó so sánh hai chuỗi thu được từ hai mảng cho bằng nhau

JSON.stringify([1,{a:1},2]) == JSON.stringify([1,{a:1},2]) //true

JSON.stringify([1,{a:1},2]) == JSON.stringify([1,{a:2},2]) //false

JSON.stringify([1,{a:1},2]) == JSON.stringify([1,{a:2},[3,4],2]) //false

JSON.stringify([1,{a:1},[3,4],2]) == JSON.stringify([1,{a:2},[3,4],2]) //false

JSON.stringify([1,{a:2},[3,4],2]) == JSON.stringify([1,{a:2},[3,4],2]) //true

JSON.stringify([1,{a:2},[3,4],2]) == JSON.stringify([1,{a:2},[3,4,[5]],2]) //false

JSON.stringify([1,{a:2},[3,4,[4]],2]) == JSON.stringify([1,{a:2},[3,4,[5]],2]) //false

JSON.stringify([1,{a:2},[3,4,[5]],2]) == JSON.stringify([1,{a:2},[3,4,[5]],2]) //true

Đệ quy & hoạt động trên mảng NESTED :

function ArrEQ(a1,a2){
   return( 
        //:Are both elements arrays?
        Array.isArray(a1)&&Array.isArray(a2) 
        ?
        //:Yes: Test each entry for equality:
        a1.every((v,i)=>(ArrEQ(v,a2[i])))
        :
        //:No: Simple Comparison:
        (a1===a2)
   );;
};;

console.log( "Works With Nested Arrays:" );
console.log( ArrEQ( 
    [1,2,3,[4,5,[6,"SAME/IDENTICAL"]]],
    [1,2,3,[4,5,[6,"SAME/IDENTICAL"]]]
));;     
console.log( ArrEQ( 
    [1,2,3,[4,5,[6,"DIFFERENT:APPLES" ]]],
    [1,2,3,[4,5,[6,"DIFFERENT:ORANGES"]]]
));;  

Hoạt động với các đối số MULTIPLE với mảng NESTED :

//:Return true if all of the arrays equal.
//:Works with nested arrays.
function AllArrEQ(...arrays){
    for(var i = 0; i < (arrays.length-1); i++ ){
        var a1 = arrays[i+0];
        var a2 = arrays[i+1];
        var res =( 
            //:Are both elements arrays?
            Array.isArray(a1)&&Array.isArray(a2) 
            ?
            //:Yes: Compare Each Sub-Array:
            //:v==a1[i]
            a1.every((v,i)=>(AllArrEQ(v,a2[i])))
            :
            //:No: Simple Comparison:
            (a1===a2)
        );;
        if(!res){return false;}
    };;
    return( true );
};;

console.log( AllArrEQ( 
        [1,2,3,[4,5,[6,"ALL_EQUAL"   ]]],
        [1,2,3,[4,5,[6,"ALL_EQUAL"   ]]],
        [1,2,3,[4,5,[6,"ALL_EQUAL"   ]]],
        [1,2,3,[4,5,[6,"ALL_EQUAL"   ]]],
));; 

In a simple way uning stringify but at same time thinking in complex arrays:

**Simple arrays**:  
var a = [1,2,3,4];  
var b = [4,2,1,4];  
JSON.stringify(a.sort()) === JSON.stringify(b.sort()) // true  

**Complex arrays**:  
var a = [{id:5,name:'as'},{id:2,name:'bes'}];  
var b = [{id:2,name:'bes'},{id:5,name:'as'}];  
JSON.stringify(a.sort(function(a,b) {return a.id - b.id})) === JSON.stringify(b.sort(function(a,b) {return a.id - b.id})) // true  

**Or we can create a sort function**  

function sortX(a,b) {  
return a.id -b.id; //change for the necessary rules  
}  
JSON.stringify(a.sort(sortX)) === JSON.stringify(b.sort(sortX)) // true