Comment comparer deux tableaux sont égaux en utilisant Javascript?

Une approche moins robuste, mais ça marche.

a = [2, 4, 5].toString();
b = [2, 4, 5].toString();

console.log(a===b);

var array3 = array1 === array2

Cela va comparer si array1 et array2 sont le même objet tableau en mémoire, ce qui n'est pas ce que vous voulez.

Pour faire ce que vous voulez, vous aurez besoin de vérifier si les deux tableaux ont la même longueur, et, que chaque membre de chaque index est identique.

En supposant que votre tableau est rempli de primitives-nombres et ou chaînes-quelque chose comme ça devrait faire

function arraysAreIdentical(arr1, arr2){
    if (arr1.length !== arr2.length) return false;
    for (var i = 0, len = arr1.length; i < len; i++){
        if (arr1[i] !== arr2[i]){
            return false;
        }
    }
    return true; 
}

Vous pouvez essayer cette approche simple

var array1 = [4,8,9,10];
var array2 = [4,8,9,10];

console.log(array1.join('|'));
console.log(array2.join('|'));

if (array1.join('|') === array2.join('|')) {
	console.log('The arrays are equal.');
} else {
	console.log('The arrays are NOT equal.');
}

array1 = [[1,2],[3,4],[5,6],[7,8]];
array2 = [[1,2],[3,4],[5,6],[7,8]];

console.log(array1.join('|'));
console.log(array2.join('|'));

if (array1.join('|') === array2.join('|')) {
	console.log('The arrays are equal.');
} else {
	console.log('The arrays are NOT equal.');
}

Si la position des valeurs n'est pas importante, vous pouvez d'abord trier les tableaux.

if (array1.sort().join('|') === array2.sort().join('|')) {
    console.log('The arrays are equal.');
} else {
    console.log('The arrays are NOT equal.');
}

Une version plus moderne:

function arraysEqual(a, b) {
  a = Array.isArray(a) ? a : [];
  b = Array.isArray(b) ? b : [];
  return a.length === b.length && a.every((el, ix) => el === b[ix]);
}

Forcer des arguments non-array à des tableaux vides empêche a.every() d'exploser.

Si vous voulez juste voir si les tableaux ont le même ensemble d'éléments, vous pouvez utiliser Array.includes():

function arraysContainSame(a, b) {
  a = Array.isArray(a) ? a : [];
  b = Array.isArray(b) ? b : [];
  return a.length === b.length && a.every(el => b.includes(el));
}

Utilisez lodash. Dans la syntaxe ES6:

import isEqual from 'lodash/isEqual';
let equal = isEqual([1,2], [1,2]);  // true

Ou versions précédentes de js:

var isEqual = require('lodash/isEqual');
var equal = isEqual([1,2], [1,2]);  // true

Si vous comparez 2 tableaux mais des valeurs qui ne sont pas dans le même index, essayez ceci

var array1=[1,2,3,4]
var array2=[1,4,3,2]
var is_equal = array1.length==array2.length && array1.every(function(v,i) { return ($.inArray(v,array2) != -1)})
console.log(is_equal)

Voici le code. Qui est capable de comparer les tableaux par n'importe quelle position.

var array1 = [4,8,10,9];

var array2 = [10,8,9,4];

var is_same = array1.length == array2.length && array1.every(function(element, index) {
    //return element === array2[index];
  if(array2.indexOf(element)>-1){
    return element = array2[array2.indexOf(element)];
  }
});
console.log(is_same);

function isEqual(a) {
if (arrayData.length > 0) {
    for (var i in arrayData) {
        if (JSON.stringify(arrayData[i]) === JSON.stringify(a)) {
            alert("Ya existe un registro con esta informacion");
            return false;
        }
    }
}
}

Cochez cette exemple

Essayer de faire comme ceci: array1.compare(array2)=true

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;

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