Mam te dwie tablice: jedna jest wypełniona informacjami z żądania Ajax, a druga przechowuje przyciski, na które klika użytkownik. Używam tego kodu (wypełniłem przykładowe numery):

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

Ale zawsze daje false, nawet jeśli dwie tablice są takie same, ale mają inną nazwę. (Sprawdziłem to w konsoli JS Chrome). Czy jest więc jakiś sposób, abym mógł wiedzieć, czy te dwie tablice zawierają to samo? Dlaczego to daje false? Skąd mam wiedzieć, których wartości w pierwszej tablicy nie ma w drugiej?

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;

}

Zauważ, że nie modyfikuje to oryginalnych tablic w przeciwieństwie do poprzedniej odpowiedzi.

Jeśli elementy twojej tablicy nie są obiektami - jeśli są to na przykład liczby lub ciągi znaków, możesz porównać ich połączone ciągi, aby sprawdzić, czy mają te same elementy członkowskie w dowolnej kolejności -

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

Jeśli chcesz sprawdzić tylko, czy dwie tablice mają te same wartości (niezależnie od liczby wystąpień i kolejności każdej wartości), możesz to zrobić za pomocą lodash :

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

Krótkie, proste i ładne!

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

Może?

Dlaczego twój kod nie działa

JavaScript ma prymitywne typy danych i inne niż pierwotne typy danych.

W przypadku pierwotnych typów danych ==i ===sprawdź, czy elementy po obu stronach słupków mają tę samą wartość. Dlatego1 === 1 to prawda.

W przypadku nieprymitywnych typów danych, takich jak tablice, ==i ===sprawdź równość odwołań. Oznacza to, że sprawdzają, czy arr1i arr2są tym samym obiektem. W Twoim przykładzie dwie tablice mają te same obiekty w tej samej kolejności, ale nie są równoważne.

Rozwiązania

Dwie tablice arr1i arr2mają te same elementy członkowskie wtedy i tylko wtedy, gdy:

• Wszystko arr2jest w środkuarr1

I

• Wszystko arr1jest w środkuarr2

Więc to załatwi sprawę (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`

To drugie rozwiązanie wykorzystujące podkreślenie jest bliższe temu, co próbujesz zrobić:

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

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

Działa, ponieważ isEqualsprawdza „głęboką równość”, co oznacza, że ​​szuka czegoś więcej niż tylko równości odniesienia i porównuje wartości.

Rozwiązanie trzeciego pytania

Zapytałeś również, jak dowiedzieć się, które rzeczy arr1nie są zawarte w arr2.

To wystarczy (ES2015):

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

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

Możesz także użyć Underscore difference: metoda:

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

AKTUALIZACJA

Zobacz komentarz @ Redu - moje rozwiązanie jest dla sameMembers, ale to, co możesz mieć na myśli, jest sameMembersInOrderrównież znane jako deepEquals.

AKTUALIZACJA 2

Jeśli nie przejmujesz się kolejnością członków tablic, ES2015 + Setmoże być lepszą strukturą danych niż Array. Zobacz notatki MDN o tym, jak wdrożyć isSupersetidifference używać niebezpiecznych małp łatania.

Sprawdzenie równości obiektów:JSON.stringify(array1.sort()) === JSON.stringify(array2.sort())

Powyższy test działa również z tablicami obiektów, w którym to przypadku użyj funkcji sortowania, jak opisano w http://www.w3schools.com/jsref/jsref_sort.asp

Może wystarczyć dla małych tablic z płaskimi schematami JSON.

Naszym celem jest po prostu sprawdzenie, czy 2 tablice są równymi zbiorami. zbiór to zbiór zdefiniowany matematycznie . Najszybsze sortowanie asymptotycznie zajmuje O (nlog (n)) czasu. Więc jeśli posortujesz tablicę, zajmie to co najmniej O (nlog (n)) czasu. Ale możesz wykonać to zadanie szybciej , co asymptotycznie zajmuje O (n) czasu (przypadek średni, a nie najgorszy przypadek) ze słownikową strukturą danych. W JS słownik to po prostu obiekt zawierający klucze i wartości.

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

Zauważ, że ta funkcja działa z tablicami typów pierwotnych oraz zakłada a1i a2jest tablicami.

A co z tym? ES 2017 przypuszczam:

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

Pierwszy warunek sprawdza, czy obie tablice mają taką samą długość, a drugi warunek sprawdza, czy pierwsza tablica jest podzbiorem drugiej tablicy. Połączenie tych 2 warunków powinno skutkować porównaniem wszystkich pozycji z 2 tablic, niezależnie od kolejności elementów.

Powyższy kod będzie działał tylko wtedy, gdy obie tablice mają niepowtarzalne elementy.

Kiedy porównujesz te dwie tablice, porównujesz obiekty, które reprezentują tablice, a nie zawartość.

Będziesz musiał użyć funkcji, aby porównać te dwa. Możesz napisać własny, który po prostu zapętla jeden i porównuje go z drugim po sprawdzeniu, czy długości są takie same.

Proste rozwiązanie dla płytkiej równości przy użyciu ES6:

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

Tworzy płytkie kopie każdej tablicy i sortuje je. Następnie używa some()do zapętlania arr1testwartości, porównując każdą wartość z wartością arr2testz tego samego indeksu. Jeśli wszystkie wartości są równe, some()zwraca falsei z kolei zwraca equalwartość true.

Można również użyć every(), ale musiałby cyklicznie przechodzić przez każdy element tablicy, aby spełnić truewynik, podczas gdy some()baile, gdy tylko znajdzie wartość, która nie jest równa:

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

Miałem proste wartości całkowite w projekcie Game.
Miałem mniejszą liczbę wartości w każdej tablicy, potrzebowałem też nienaruszonej oryginalnej tablicy.
Zrobiłem więc poniższe, działało dobrze. (Kod edytowany do wklejenia tutaj)

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;

Mam nadzieję, że to pomoże.

Korzystanie z ES6

Użyjemy equalsfunkcji Ramdy , ale zamiast tego możemy użyć funkcji Lodash lub Underscore isEqual:

const R = require('ramda');

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

Korzystając z narzędzia rozprzestrzeniania, unikamy mutowania oryginalnych tablic i utrzymujemy naszą funkcję w czystości.

Możesz użyć reducezamiast pętli, aby wyglądać sprytnie, ale ryzykujesz, że inni programiści pomyślą o Tobie jako o mądrym dupku.

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

Większość innych rozwiązań używa sortowania, O (n * log n), korzysta z bibliotek lub ma złożoność O (n ^ 2).

Oto rozwiązanie w czystym Javascript z liniową złożonością, 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;
  }

  // Check that all items in arr1 are in arr2
  for (let i = arr1.length - 1; i >= 0; i--) {
    const v = vKey(i, arr1[i]);
    if (d1[v] !== d2[v]) return false;
  }

  // Check that all items in arr2 are in arr1
  for (let i = arr2.length - 1; i >= 0; i--) {
    const v = vKey(i, arr2[i]);
    if (d1[v] !== d2[v]) return false;
  }

  return true
}

Testy:

arr1= (2) [1, 2]
arr2= (2) [1, 2]
compareArrays(arr1, arr2) => true
compareArrays(arr1, arr2, {enforceOrder: true}) => true
-------
arr1= (2) [1, 2]
arr2= (2) [2, 1]
compareArrays(arr1, arr2) => true
compareArrays(arr1, arr2, {enforceOrder: true}) => false
-------
arr1= (2) [2, 1]
arr2= (2) [1, 2]
compareArrays(arr1, arr2) => true
compareArrays(arr1, arr2, {enforceOrder: true}) => false
-------
arr1= (2) [2, 2]
arr2= (2) [1, 2]
compareArrays(arr1, arr2) => false
compareArrays(arr1, arr2, {enforceOrder: true}) => false
-------
arr1= (2) [1, 2]
arr2= (2) [2, 2]
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= (2) ["1", 2]
arr2= (2) [2, "1"]
compareArrays(arr1, arr2) => true
compareArrays(arr1, arr2, {enforceOrder: true}) => false
-------
arr1= []
arr2= []
compareArrays(arr1, arr2) => true
compareArrays(arr1, arr2, {enforceOrder: true}) => true

Jeśli korzystasz z Prototype Framework, możesz użyć metody intersect tablicy, aby dowiedzieć się, czy są takie same (niezależnie od kolejności):

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

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

uprzejmie sprawdź tę odpowiedź

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

Odpowiadam po długim czasie, ale mam nadzieję, że pomoże to komuś, kto szuka prostego rozwiązania i nowoczesnych nowicjuszy.

Teraz możemy to osiągnąć za pomocą wielu bibliotek, takich jak lodash,underscore itp (które staje się częścią projektu w dzisiejszych czasach ze względu na prostotę, wiele funkcji i wysoką użytkowania)

Możesz użyć przecięcia z biblioteki lodash.

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

To zadziała dla każdego typu danych.

Jeśli chcesz porównać dwie tablice i sprawdzić, czy jakikolwiek obiekt jest taki sam w obu tablicach, zadziała. Przykład:

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

Tutaj 'd' jest wspólne dla obu tablic, więc ta funkcja zwróci wartość 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;
  }

Spróbuj tego

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

Mam inny sposób na podstawie zaakceptowanej odpowiedzi.

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

Funkcja porównywania dwóch tablic, aby sprawdzić, czy obie mają te same elementy. Nawet jeśli są niesprawne ...

Jest to dobre dla prostych tablic. [String, Number, Boolean, null, NaN].

Nie używam .sort (), modyfikuje oryginalną tablicę. Niektórzy mówią, że to źle ...

Uwaga. Ta funkcja jest ograniczona, nie może porównywać Obiektów „[], {}” ani funkcji w tych tablicach, tablice, których ona sama jest Obiektem.

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

Proste rozwiązanie, aby porównać dwie tablice:

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

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

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