Ich habe diese zwei Arrays: eines ist mit Informationen aus einer Ajax-Anfrage gefüllt und ein anderes speichert die Schaltflächen, auf die der Benutzer klickt. Ich benutze diesen Code (ich habe mit Probennummern gefüllt):

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

Aber es gibt immer false, auch wenn die beiden Arrays gleich sind, aber mit unterschiedlichen Namen. (Ich habe dies in der JS-Konsole von Chrome überprüft.) Kann ich also auf irgendeine Weise wissen, ob diese beiden Arrays dasselbe enthalten? Warum gibt es false? Wie kann ich wissen, welche Werte im ersten Array nicht im zweiten enthalten sind?

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;

}

Beachten Sie, dass dies die ursprünglichen Arrays im Gegensatz zu einer vorherigen Antwort nicht ändert.

Wenn Ihre Array-Elemente keine Objekte sind - wenn es sich beispielsweise um Zahlen oder Zeichenfolgen handelt, können Sie die verknüpften Zeichenfolgen vergleichen, um festzustellen, ob sie in beliebiger Reihenfolge dieselben Mitglieder haben.

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

Wenn Sie nur überprüfen möchten, ob zwei Arrays dieselben Werte haben (unabhängig von der Anzahl der Vorkommen und der Reihenfolge der einzelnen Werte), können Sie dies mithilfe von lodash tun :

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

Kurz, einfach und hübsch!

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

Vielleicht?

Warum Ihr Code nicht funktioniert hat

JavaScript hat primitive Datentypen und nicht-primitive Datentypen.

Für primitive Datentypen, ==und ===prüfen , ob die Dinge , die auf beiden Seiten der Stäbe haben den gleichen Wert. Deshalb1 === 1 ist es wahr.

Für nicht-primitive Datentypen wie Arrays ==und ===Kontrolle Referenz Gleichheit. Das heißt, sie prüfen, ob arr1und arr2dasselbe Objekt sind. In Ihrem Beispiel haben die beiden Arrays dieselben Objekte in derselben Reihenfolge, sind jedoch nicht gleichwertig.

Lösungen

Zwei Arrays arr1und arr2haben genau dann dieselben Mitglieder, wenn:

• Alles in arr2ist inarr1

UND

• Alles in arr1ist inarr2

Das reicht also aus (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`

Diese zweite Lösung mit Underscore entspricht eher dem, was Sie versucht haben:

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

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

Es funktioniert, weil isEqualnach "tiefer Gleichheit" gesucht wird, was bedeutet, dass mehr als nur Referenzgleichheit betrachtet und Werte verglichen werden.

Eine Lösung für Ihre dritte Frage

Sie haben auch gefragt, wie Sie herausfinden können, in welchen Dingen arr1nichts enthalten istarr2 .

Dies wird es tun (ES2015):

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

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

Sie können auch die differencefolgende Methode verwenden:

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

AKTUALISIEREN

Siehe @ Redu's Kommentar - meine Lösung ist für sameMembers, aber was Sie vielleicht im Sinn haben, ist sameMembersInOrderauch bekannt als deepEquals.

UPDATE 2

Wenn Sie sich nicht um die Reihenfolge der Mitglieder der Arrays kümmern, ist ES2015 + Setmöglicherweise eine bessere Datenstruktur als Array. LesenisSupersetdifference Sie die MDN-Hinweise zur Implementierung und Verwendung gefährlicher Affen-Patches.

Objektgleichheitsprüfung:JSON.stringify(array1.sort()) === JSON.stringify(array2.sort())

Der obige Test funktioniert auch mit Arrays von Objekten. In diesem Fall wird eine Sortierfunktion verwendet, die unter http://www.w3schools.com/jsref/jsref_sort.asp dokumentiert ist

Könnte für kleine Arrays mit flachen JSON-Schemas ausreichen.

Unser Ziel ist es grundsätzlich zu überprüfen, ob 2 Arrays gleiche Mengen sind. set ist die mathematisch definierte Menge . Die schnellste asymptotische Sortierung benötigt O (nlog (n)) Zeit. Wenn Sie also ein Array sortieren, dauert es mindestens O (nlog (n)) . Sie können diese Aufgabe jedoch schneller erledigen , was bei einer Wörterbuchdatenstruktur asymptotisch O (n) Zeit in Anspruch nimmt (Durchschnittsfall nicht Worst Case). In JS ist ein Wörterbuch einfach ein Objekt mit Schlüsseln und Werten.

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

Beachten Sie, dass diese Funktion mit Arrays primitiver Typen funktioniert a1und a2Arrays annimmt und sind.

Was ist damit? ES 2017 nehme ich an:

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

Die erste Bedingung prüft, ob beide Arrays dieselbe Länge haben, und die zweite Bedingung prüft, ob das erste Array eine Teilmenge des zweiten Arrays ist. Die Kombination dieser beiden Bedingungen sollte dann zu einem Vergleich aller Elemente der beiden Arrays führen, unabhängig von der Reihenfolge der Elemente.

Der obige Code funktioniert nur, wenn beide Arrays nicht doppelte Elemente enthalten.

Wenn Sie diese beiden Arrays vergleichen, vergleichen Sie die Objekte, die die Arrays darstellen, nicht den Inhalt.

Sie müssen eine Funktion verwenden, um die beiden zu vergleichen. Sie können Ihre eigene schreiben, die einfach eine Schleife durchläuft und diese mit der anderen vergleicht, nachdem Sie überprüft haben, ob die Längen gleich sind.

Einfache Lösung für flache Gleichstellung mit ES6:

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

Erstellt flache Kopien jedes Arrays und sortiert sie. Verwendet dann some()eine Schleife durch arr1testWerte und vergleicht jeden Wert mit dem Wert in arr2testmit demselben Index. Sind alle Werte gleich sind, some()kehrt false, und wiederum equalausgewertet true.

Könnte auch verwendet werden every(), müsste aber jedes Element im Array durchlaufen, um ein trueErgebnis zu erzielen , während some()es sich retten wird, sobald es einen Wert findet, der nicht gleich ist:

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

Ich hatte einfache ganzzahlige Werte in einem Spielprojekt.
Hatte weniger Werte in jedem Array. Außerdem brauchte
ich das ursprüngliche Array unberührt. Also habe ich das Folgende getan, es hat gut funktioniert. (Code bearbeitet, um hier einzufügen)

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;

Hoffentlich hilft das.

Verwenden von ES6

Wir werden Ramdas equalsFunktion verwenden, aber stattdessen können wir die von Lodash oder Underscore verwenden isEqual:

const R = require('ramda');

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

Mit dem Spread-Opporator vermeiden wir die Mutation der ursprünglichen Arrays und halten unsere Funktion rein.

Sie können reduceanstelle von Loops verwenden, um clever zu wirken, aber auf die Gefahr hin, dass Ihre Kollegen Sie als Smart-Ass betrachten.

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

Wenn die Elemente im Array Grundelemente (Zahlen oder einzelne Zeichen) sind, können Sie eine Kombination aus Längenvergleich und Verwendung von Mengen verwenden.

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
}

Es ist bereits 2020, aber ich habe festgestellt, dass die meisten anderen Lösungen sort, O (n * log n), Bibliotheken oder O (n ^ 2) -Komplexität verwenden.

Hier ist eine reine Javascript-Lösung mit linearer Komplexität, 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
}

Tests:

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

Wenn Sie das Prototype Framework verwenden, können Sie die intersect- Methode eines Arrays verwenden, um herauszufinden, ob sie identisch sind (unabhängig von der Reihenfolge):

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

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

Bitte überprüfen Sie diese Antwort

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

Antworten Sie nach langer Zeit, aber hoffen Sie, dass dies jemandem hilft, der nach einer einfachen Lösung und modernen Neulingen sucht.

Jetzt können wir diese mit mehreren Bibliotheken wie erreichen lodash, underscoreetc. (dieser Teil des Projektes heute aufgrund der Einfachheit, mehr Funktionen und hoher Nutzung wird)

Sie können die Kreuzung aus der Lodash-Bibliothek verwenden.

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

Dies funktioniert für jeden Datentyp.

Wenn Sie zwei Arrays vergleichen und prüfen möchten, ob ein Objekt in beiden Arrays identisch ist, funktioniert dies. Beispiel:

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

Hier ist 'd' in beiden Arrays gleich, sodass diese Funktion den wahren Wert zurückgibt.

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

Versuche dies

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

Ich habe einen anderen Weg basierend auf der akzeptierten Antwort.

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

Eine Funktion zum Vergleichen von zwei Arrays, um zu überprüfen, ob beide dieselben Elemente haben. Auch wenn sie nicht in Ordnung sind ...

Es ist gut für einfache Arrays. [String, Number, Boolean, null, NaN].

Ich verwende nicht .sort (), es ändert das ursprüngliche Array. Einige sagen, es ist schlecht ...

Vorsicht. Diese Funktion ist eingeschränkt und kann keine Objekte "[], {}" oder Funktionen in diesen Arrays vergleichen. Arrays selbst sind Objekte.

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

Einfache Lösung zum Vergleichen der beiden Arrays:

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

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

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