Ho questi due array: uno è pieno di informazioni da una richiesta ajax e un altro memorizza i pulsanti su cui l'utente fa clic. Uso questo codice (ho inserito i numeri di esempio):

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

Ma dà sempre false, anche se i due array sono uguali, ma con un nome diverso. (L'ho controllato nella console JS di Chrome). Quindi, c'è un modo per sapere se questi due array contengono lo stesso? Perché sta dando false? Come posso sapere quali valori nel primo array non sono nel secondo?

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;

}

Nota che questo non modifica gli array originali a differenza di una risposta precedente.

Se gli elementi dell'array non sono oggetti, ad esempio se sono numeri o stringhe, puoi confrontare le loro stringhe unite per vedere se hanno gli stessi membri in qualsiasi ordine

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

Se vuoi controllare solo se due array hanno gli stessi valori (indipendentemente dal numero di occorrenze e dall'ordine di ogni valore) puoi farlo usando lodash :

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

Breve, semplice e carino!

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

Può essere?

Perché il tuo codice non ha funzionato

JavaScript ha tipi di dati primitivi e tipi di dati non primitivi.

Per i tipi di dati primitivi ==e ===controlla se le cose su entrambi i lati delle barre hanno lo stesso valore. Ecco perché 1 === 1è vero.

Per i tipi di dati non primitivi come gli array ==e ===verifica l'uguaglianza dei riferimenti. Cioè, controllano se arr1e arr2sono lo stesso oggetto. Nel tuo esempio, i due array hanno gli stessi oggetti nello stesso ordine, ma non sono equivalenti.

soluzioni

Due array arr1e arr2hanno gli stessi membri se e solo se:

• Tutto dentro arr2è dentroarr1

E

• Tutto dentro arr1è dentroarr2

Quindi questo farà il trucco (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`

Questa seconda soluzione che utilizza il carattere di sottolineatura è più vicina a ciò che stavi cercando di fare:

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

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

Funziona perché isEqualverifica "l'uguaglianza profonda", il che significa che non si limita a considerare l'uguaglianza dei riferimenti e confronta i valori.

Una soluzione alla tua terza domanda

Hai anche chiesto come scoprire in quali cose arr1non sono contenute arr2.

Questo lo farà (ES2015):

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

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

Puoi anche usare il differencemetodo del carattere di sottolineatura ::

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

AGGIORNARE

Vedi il commento di @ Redu: la mia soluzione è per sameMembers, ma ciò che potresti avere in mente è sameMembersInOrderanche noto come deepEquals.

AGGIORNAMENTO 2

Se non ti interessa l'ordine dei membri degli array, ES2015 + Setpotrebbe essere una struttura dati migliore di Array. Vedere le note MDN su come implementare isSupersetedifference utilizzare pericolose patch di scimmia.

Controllo dell'uguaglianza degli oggetti:JSON.stringify(array1.sort()) === JSON.stringify(array2.sort())

Il test di cui sopra funziona anche con array di oggetti, nel qual caso usa una funzione di ordinamento come documentato in http://www.w3schools.com/jsref/jsref_sort.asp

Potrebbe essere sufficiente per piccoli array con schemi JSON piatti.

Il nostro scopo è fondamentalmente verificare se 2 array sono insiemi uguali. set è l' insieme definito matematicamente . L'ordinamento più veloce in modo asintotico richiede tempo O (nlog (n)) . Quindi, se si ordina un array, ci vorrà almeno O (nlog (n)) tempo. Ma puoi eseguire questa operazione più velocemente , il che richiede asintoticamente O (n) tempo (caso medio non caso peggiore) con una struttura dati del dizionario. In JS, un dizionario è semplicemente un oggetto con chiavi e valori.

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

Si noti che questa funzione funziona con array di tipi primitivi e presuppone a1e a2siano array.

Che dire di questo? ES 2017 suppongo:

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

La prima condizione controlla se entrambi gli array hanno la stessa lunghezza e la seconda condizione controlla se il primo array è un sottoinsieme del secondo array. La combinazione di queste 2 condizioni dovrebbe quindi risultare in un confronto di tutti gli elementi dei 2 array indipendentemente dall'ordinamento degli elementi.

Il codice precedente funzionerà solo se entrambi gli array hanno elementi non duplicati.

Quando confronti questi due array, stai confrontando gli oggetti che rappresentano gli array, non il contenuto.

Dovrai usare una funzione per confrontare i due. Potresti scrivere il tuo che semplicemente si ripete l'uno e lo confronta con l'altro dopo aver verificato che le lunghezze siano le stesse.

Soluzione semplice per l'uguaglianza superficiale utilizzando ES6:

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

Crea copie superficiali di ogni array e le ordina. Quindi utilizza some()per scorrere i arr1testvalori, controllando ogni valore rispetto al valore arr2testcon lo stesso indice. Se tutti i valori sono uguali, some()i rendimenti false, ed a sua volta equalrestituisce true.

Potrebbe anche usare every(), ma dovrebbe scorrere ogni elemento nell'array per soddisfare un truerisultato, mentre some()verrà salvato non appena trova un valore diverso da quello:

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

Avevo valori interi semplici in un progetto di gioco
Avevo un numero inferiore di valori in ogni array, inoltre
, avevo bisogno di quell'array originale intatto Quindi, ho fatto quanto segue, ha funzionato bene. (Codice modificato per incollare qui)

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;

Spero che aiuti.

Utilizzando ES6

Useremo la equalsfunzione di Ramda , ma invece possiamo usare Lodash o Underscore isEqual:

const R = require('ramda');

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

Utilizzando lo spread opporator, evitiamo di modificare gli array originali e manteniamo pura la nostra funzione.

Puoi usare reduceinvece dei loop per sembrare intelligente, ma con il rischio che i tuoi colleghi sviluppatori ti considerino un idiota.

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

Se gli elementi nell'array sono primitivi (numeri o singoli caratteri), è possibile utilizzare una combinazione di confronto delle lunghezze e utilizzo di set.

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
}

È già il 2020 ma ho notato che la maggior parte delle altre soluzioni usa sort, O (n * log n), usa librerie o ha complessità O (n ^ 2).

Ecco una soluzione Javascript pura con complessità lineare, 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
}

test:

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

Se stai usando Prototype Framework, puoi usare il metodo intersect di un array per scoprire che sono uguali (indipendentemente dall'ordine):

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

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

si prega di controllare questa risposta

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

Rispondere dopo molto tempo, ma spero che questo possa aiutare qualcuno che cerca una soluzione semplice e neofiti moderni.

Ora siamo in grado di ottenere questo utilizzando librerie multiple come lodash, underscoree così via (questi entra a far parte del progetto oggi a causa semplicità, funzionalità multiple e un utilizzo elevato)

Puoi usare l'intersezione dalla libreria lodash.

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

Funzionerà per qualsiasi tipo di dati ..

Se vuoi confrontare due array e controllare se un oggetto è uguale in entrambi gli array, funzionerà. Esempio :

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

Qui, 'd' è comune in entrambi gli array, quindi questa funzione restituirà il valore vero.

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

Prova questo

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

Ho un altro modo basato sulla risposta accettata.

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

Una funzione per confrontare due array, per verificare se entrambi hanno gli stessi elementi. Anche se sono fuori servizio ...

Va bene per array semplici. [String, numero, booleano, null, NaN].

Non uso .sort (), modifica l'array originale. Alcuni dicono che è brutto ...

Attenzione. Questa funzione è limitata e non può confrontare Oggetti "[], {}" o funzioni all'interno di questi Array, gli array in sé sono Oggetti.

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

Soluzione semplice per confrontare i due array:

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

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

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