У меня есть два массива: один заполнен информацией из запроса ajax, а другой хранит кнопки, на которые нажимает пользователь. Я использую этот код (я набрал номера образцов):

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

Но всегда дает false, даже если два массива одинаковые, но с разными именами. (Я проверил это в консоли Chrome JS). Итак, есть ли способ узнать, содержат ли эти два массива то же самое? Почему это дает false? Как узнать, каких значений в первом массиве нет во втором?

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;

}

Обратите внимание, что это не изменяет исходные массивы, в отличие от предыдущего ответа.

Если элементы вашего массива не являются объектами - например, если они являются числами или строками, вы можете сравнить их соединенные строки, чтобы увидеть, имеют ли они одинаковые элементы в любом порядке -

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

Если вы хотите проверить, имеют ли два массива одинаковые значения (независимо от количества вхождений и порядка каждого значения), вы можете сделать это с помощью lodash :

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

Коротко, просто и красиво!

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

Может быть?

Почему ваш код не работал

В JavaScript есть примитивные типы данных и непримитивные типы данных.

Для примитивных типов данных ==и ===проверьте, имеют ли значения по обе стороны от полосок одинаковое значение. Вот почему 1 === 1верно.

Для непримитивных типов данных, таких как массивы, ==и ===проверьте равенство ссылок. То есть они проверяют, являются ли arr1и arr2являются одним и тем же объектом. В вашем примере два массива имеют одинаковые объекты в одном порядке, но не эквивалентны.

Решения

Два массива arr1и arr2имеют одинаковые члены тогда и только тогда, когда:

• Все arr2вarr1

И

• Все arr1вarr2

Итак, это поможет (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`

Это второе решение с использованием Underscore ближе к тому, что вы пытались сделать:

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

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

Он работает, потому что isEqualпроверяет «глубокое равенство», что означает, что он смотрит не только на ссылочное равенство и сравнивает значения.

Решение вашего третьего вопроса

Вы также спросили, как узнать, какие вещи arr1не содержатся в arr2.

Это сделает это (ES2015):

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

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

Вы также можете использовать differenceметод Underscore ::

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

ОБНОВИТЬ

См. Комментарий @ Redu - мое решение для sameMembers, но то, что вы, возможно, имеете в виду, sameMembersInOrderтакже известно как deepEquals.

ОБНОВЛЕНИЕ 2

Если вам не важен порядок членов массивов, ES2015 + Setможет быть лучшей структурой данных, чем Array. См. Примечания MDN о том, как реализовать isSupersetиdifference использовать опасные исправления для обезьян.

Проверка равенства объектов:JSON.stringify(array1.sort()) === JSON.stringify(array2.sort())

Вышеупомянутый тест также работает с массивами объектов, и в этом случае используйте функцию сортировки, как описано в http://www.w3schools.com/jsref/jsref_sort.asp

Может хватить для небольших массивов с плоскими схемами JSON.

Наша цель - проверить, являются ли 2 массива равными множествами. набор - это математически определенный набор . Самая быстрая асимптотическая сортировка занимает O (nlog (n)) времени. Итак, если вы отсортируете массив, это займет как минимум O (nlog (n)) времени. Но вы можете выполнить эту задачу быстрее , что асимптотически занимает время O (n) (средний случай, а не худший случай) со структурой данных словаря. В JS словарь - это просто объект с ключами и значениями.

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

Обратите внимание , что эта функция работает с массивами примитивных типов и предполагает a1и a2массивы.

Как насчет этого? ES 2017 я полагаю:

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

Первое условие проверяет, имеют ли оба массива одинаковую длину, а второе условие проверяет, является ли 1-й массив подмножеством 2-го массива. Объединение этих двух условий должно привести к сравнению всех элементов двух массивов независимо от порядка элементов.

Приведенный выше код будет работать только в том случае, если оба массива не имеют повторяющихся элементов.

Когда вы сравниваете эти два массива, вы сравниваете объекты, представляющие массивы, а не содержимое.

Вам нужно будет использовать функцию для сравнения этих двух. Вы можете написать свой собственный, который просто зацикливается на одном и сравнивает его с другим после того, как вы проверите, что длины одинаковы.

Простое решение для поверхностного равенства с использованием ES6:

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

Создает мелкие копии каждого массива и сортирует их. Затем используется some()для перебора arr1testзначений, сравнивая каждое значение со значением arr2testс тем же индексом. Если все значения равны, some()возвращается falseи, в свою очередь, equalоценивается как true.

Можно также использовать every(), но ему придется перебирать каждый элемент в массиве, чтобы получить trueрезультат, тогда как он some()откажется, как только найдет значение, которое не равно:

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

У меня были простые целочисленные значения в игровом проекте.
Меньшее количество значений в каждом массиве также нуждалось в том, чтобы исходный массив оставался нетронутым.
Итак, я сделал следующее, все работало нормально. (Код отредактирован для вставки сюда)

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;

Надеюсь, это поможет.

Использование ES6

Мы будем использовать equalsфункцию Ramda , но вместо этого мы можем использовать Lodash или Underscore isEqual:

const R = require('ramda');

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

Используя оппонент распространения, мы избегаем мутации исходных массивов и сохраняем нашу функцию чистой.

Вы можете использовать reduceвместо циклов, чтобы казаться умным, но рискуете, что ваши коллеги-разработчики будут думать о вас как о умнике.

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

Если элементы в массиве являются примитивами (числами или одиночными символами), вы можете использовать комбинацию сравнения длин и использования наборов.

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
}

Большинство других решений используют сортировку, O (n * log n), используют библиотеки или имеют сложность O (n ^ 2).

Вот чистое решение Javascript с линейной сложностью 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
}

Тесты:

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

Если вы используете Prototype Framework, вы можете использовать метод пересечения массива, чтобы узнать, что они одинаковы (независимо от порядка):

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

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

пожалуйста, проверьте этот ответ

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

Отвечаю спустя долгое время, но надеюсь, что это поможет кому-то, кто ищет простое решение и современных новичков.

Теперь мы можем добиться этого с помощью нескольких библиотек, таких как lodash, underscoreи т. Д. (В настоящее время они становятся частью проекта из-за простоты, множества функций и высокой степени использования).

Вы можете использовать пересечение из библиотеки lodash.

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

Это будет работать для любого типа данных ..

Если вы хотите сравнить два массива и проверить, совпадает ли какой-либо объект в обоих массивах, он будет работать. Пример :

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

Здесь 'd' является общим в обоих массивах, поэтому эта функция вернет истинное значение.

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

Попробуй это

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

У меня есть другой способ, основанный на принятом ответе.

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

Функция сравнения двух массивов, чтобы проверить, имеют ли оба одинаковые элементы. Даже если они вышли из строя ...

Это хорошо для простых массивов. [String, Number, Boolean, null, NaN].

Я не использую .sort (), он изменяет исходный массив. Некоторые говорят, что это плохо ...

Осторожно. Эта функция ограничена, она не может сравнивать объекты "[], {}" или функции в этих массивах, массивы сами по себе являются объектами.

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

Простое решение для сравнения двух массивов:

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

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

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