Сравнение двух массивов javascript

Сравнение двух массивов javascript

11 GregW [2016-04-09 20:23:00]

У меня есть два массива в Javascript, которые в настоящее время выглядят так, но обновляются HTTP-запросами (node):

Я хочу сравнить эти массивы, так что если массив внутри y, который не находится в x, он будет сохранен в новый массив — z . Обратите внимание, что иногда порядок массивов внутри массивов будет меняться, но мне не хотелось бы, чтобы это повлияло на результат.

Если массив внутри x, который не находится в y, однако, он не должен быть сохранен в z .

Я читал разницу в массиве JavaScript и смог реплицировать это, но если массив x не показан в y , он печатается на z . Мне интересно, возможно ли, чтобы это не было сохранено, только разные элементы в y ?

6 ответов

9 Решение Andy [2016-04-09 22:12:00]

Используйте функцию более высокого порядка, которая принимает массив (который изменяется с каждой итерацией y ) и возвращает новую функцию, которая работает с каждым элементом (вложенным массивом) в some . Он возвращает true , если массивы содержат одни и те же элементы независимо от порядка.

Перейдите к y и верните список массивов, которые не находятся в x .

Вы можете использовать эту функцию arrayDiff .

Он принимает два массива (A и B) и возвращает массив всех элементов, которые находятся в первом массиве, а не во втором (AB), при удалении любых дубликатов. Два элемента массива равны, если их сериализация JSON одинакова.

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

Я хочу, чтобы позиция массива была одинаковой, а значение тоже одинаково.

9 Solutions collect form web for “Как сравнить два массива равными с помощью Javascript?”

Вы можете использовать Array.prototype.every () . ( Полиэфир необходим для IE

РАБОЧАЯ ДЕМО.

Менее надежный подход, но он работает.

Это будет сравнивать, являются ли array1 и array2 одним и тем же объектом массива в памяти, что не то, что вы хотите.

Чтобы сделать то, что вы хотите, вам нужно проверить, имеют ли две массивы одинаковые длины и что каждый член в каждом индексе идентичен.

Предполагая, что ваш массив заполнен примитивами-числами и строками, что-то вроде этого должно делать

Вы можете попробовать этот простой подход

Если вы сравниваете 2 массива, но значения не входят в один и тот же индекс, попробуйте это

Более современная версия:

Принуждение аргументов без массива к пустым массивам останавливает a.every() от взрыва.

Если вы просто хотите увидеть, имеют ли массивы одинаковые элементы, вы можете использовать Array.includes() :

Попробуйте сделать так: array1.compare(array2)=true

Вот код. Который способен сравнивать массивы по любой позиции.

617040 просмотра

30 ответа

11900 Репутация автора

Я бы хотел сравнить два массива . идеально, эффективно. Ничего необычного, просто true если они идентичны, а false если нет. Неудивительно, что оператор сравнения, похоже, не работает.

JSON кодирует каждый массив, но есть ли более быстрый или «лучший» способ простого сравнения массивов без необходимости повторения каждого значения?

Ответы (30)

6 плюса

149720 Репутация автора

В тех же строках, что и JSON.encode, нужно использовать join ().

Проблема только в том, что вам нравятся типы, которые были последними сравнительными тестами. Если вам нравятся типы, вам придется петли.

Если порядок должен оставаться таким же, как это просто цикл, никакой сортировки не требуется.

60 плюса

246583 Репутация автора

Неясно, что вы подразумеваете под «идентичными». Например, массивы a и b ниже одинаковые (обратите внимание на вложенные массивы)?

Вот оптимизированная функция сравнения массива, которая в свою очередь сравнивает соответствующие элементы каждого массива с использованием строгого равенства и не рекурсивное сравнение элементов массива, которые сами являются массивами, что означает, что для приведенного выше примера arraysIdentical(a, b) вернется false . Он работает в общем случае, что решения на join() основе JSON и не будут:

Автор: Tim Down Размещён: 20.10.2011 02:46

753 плюса

21628 Репутация автора

Чтобы сравнить массивы, прокрутите их и сравните каждое значение:

Сравнение массивов:

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

Вы можете сказать: « Но гораздо быстрее сравнивать строки — нет циклов . » ну, тогда вы должны отметить, что есть циклы ARE. Первый рекурсивный цикл, который преобразует Array в строку и второй, который сравнивает две строки. Таким образом, этот метод быстрее, чем использование строки .

Читайте также:  Пропал звук медиа на телефоне

Я считаю, что большие объемы данных должны всегда храниться в массивах, а не в объектах. Однако, если вы используете объекты, их также можно частично сравнить.
Вот как:

Сравнение объектов:

Я уже говорил выше, что два экземпляра объекта никогда не будут равны, даже если они содержат одни и те же данные на данный момент:

У этого есть причина, поскольку могут быть, например, частные переменные внутри объектов.

Однако, если вы просто используете структуру объектов для хранения данных, сравнение по-прежнему возможно:

Однако помните, что это должно служить для сравнения JSON как данных, а не экземпляров классов и других вещей. Если вы хотите сравнить mor-сложные объекты, посмотрите на этот ответ, и это супер-длинная функция .
Чтобы сделать эту работу с Array.equals вами, вы должны немного изменить исходную функцию:

Бонус: Вложенные массивы indexOf и contains

Samy Bencherif подготовил полезные функции для случая, когда вы ищете определенный объект во вложенных массивах, которые доступны здесь: https://jsfiddle.net/SamyBencherif/8352y6yw/

1 плюс

869 Репутация автора

В моем случае сравниваемые массивы содержат только числа и строки. Эта функция покажет вам, содержат ли массивы одинаковые элементы.

Давайте проверим это!

Автор: yesnik Размещён: 18.03.2013 08:01

3 плюса

1451 Репутация автора

Работает с любой вложенной структурой данных и, очевидно, игнорирует методы объектов. Даже не думайте о расширении Object.prototype с помощью этого метода, когда я попробовал это один раз, jQuery сломался;)

Для большинства массивов он все же быстрее, чем большинство решений для сериализации. Это, вероятно, самый быстрый метод сравнения для массивов записей объектов.

Автор: Harry Размещён: 10.04.2013 10:38

1 плюс

2821 Репутация автора

Расширение идеи Томаша Зато. Tomas Array.prototype.compare должен быть infact, называемый Array.prototype.compareIdentical.

Здесь лучше (на мой взгляд) версия:

Автор: Igor S. Размещён: 05.06.2013 03:37

28 плюса

464 Репутация автора

Исходя из ответа Томаша Зато, я согласен с тем, что простое повторение массивов является самым быстрым. Кроме того (как уже отмечали другие), функцию следует называть равной / равной, а не сравнивать. В свете этого я модифицировал функцию, чтобы обрабатывать массивы для сходства, т. Е. Они имеют одни и те же элементы, но не в порядке — для личного использования, и я думал, что брошу его здесь для всеобщего обозрения.

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

Пример:

Я также написал быстрый jsfiddle с функцией и этим примером:
http://jsfiddle.net/Roundaround/DLkxX/

5 плюса

2803 Репутация автора

для одномерного массива вы можете просто использовать:

это также позаботится о массиве с несогласованным индексом.

Автор: Vivek Размещён: 25.09.2013 09:28

плюса

79 Репутация автора

В моем решении сравниваются объекты, а не массивы. Это будет работать так же, как Tomáš as Arrays — объекты, но без предупреждения:

Надеюсь, это поможет вам или кому-либо еще найти ответ.

263 плюса

2687 Репутация автора

Хотя это работает только для скалярных массивов (см. Примечание ниже), это коротко:

Rr, в ECMAScript 6 / CoffeeScript / TypeScript со стрелочными функциями:

(Примечание: «скаляр» здесь означает значения, которые можно сравнивать напрямую, === поэтому: числа, строки, объекты по ссылке, функции по ссылке. См. Ссылку MDN для получения дополнительной информации об операторах сравнения).

ОБНОВИТЬ

Из того, что я прочитал из комментариев, сортировка массива и сравнение могут дать точный результат:

Тогда приведенный выше код даст true

166 плюса

2064 Репутация автора

Мне нравится использовать библиотеку Underscore для проектов тяжелого кодирования массива / объекта . в Underscore и Lodash, сравниваете ли вы массивы или объекты, это выглядит следующим образом:

плюса

731 Репутация автора

плюса

1304 Репутация автора

Читайте также:  Лицензионный ключ для reimage pc repair online

Вот версия CoffeeScript, для тех, кто предпочитает это:

Все кредиты принадлежат @ tomas-zato.

Автор: Martin Размещён: 14.04.2014 03:23

плюса

405 Репутация автора

Если массив прост и порядок имеет значение, поэтому две строки могут помочь

Уменьшите проходы по одному из массивов и верните «false», если хотя бы один элемент «a» не равен элементу «b». Просто оберните это в функцию

Автор: Serge Размещён: 18.04.2014 02:32

74 плюса

14690 Репутация автора

Это, я думаю, самый простой способ сделать это, используя JSON stringify, и это может быть лучшим решением в некоторых ситуациях:

Это преобразует объекты a1 и a2 в строки, чтобы их можно было сравнить. Порядок в большинстве случаев важен, поскольку он может сортировать объект с помощью алгоритма сортировки, показанного в одном из приведенных выше ответов.

Обратите внимание, что вы больше не сравниваете объект, а строковое представление объекта. Это может быть не совсем то, что вы хотите.

Автор: radtek Размещён: 09.05.2014 02:38

1 плюс

3003 Репутация автора

этот скрипт сравнивает объекты, массивы и многомерные массивы

первая строка проверяет, является ли это примитивным типом. если это так, он сравнивает два параметра.

если они являются Объектами. он выполняет итерацию по объекту и проверяет каждый элемент рекурсивно.

1 плюс

3150 Репутация автора

Эта функция сравнивает два массива произвольной формы и dimesionality:

5 плюса

8493 Репутация автора

Если вы используете платформу тестирования, такую ​​как Mocha, с библиотекой утверждения Chai , вы можете использовать глубокое равенство для сравнения массивов.

Это должно возвращать true, только если массивы имеют равные элементы по соответствующим индексам.

1 плюс

137 Репутация автора

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

Автор: ludico8 Размещён: 22.10.2015 03:57

3 плюса

488 Репутация автора

44 плюса

66902 Репутация автора

Практический путь

Я думаю, что неправильно сказать, что конкретная реализация — это «Правильный путь», если это только «правильный» («правильный»), в отличие от «неправильного» решения. Решение Tomáš является явным улучшением по сравнению с сопоставлением массивов на основе строк, но это не значит, что оно объективно «правильно». Что такое право в любом случае? Это самый быстрый? Является ли это наиболее гибким? Легче ли это понять? Это быстрее отлаживается? Использует ли он наименьшие операции? Есть ли побочные эффекты? Ни одно решение не может иметь лучшее из всего.

Томаш мог сказать, что его решение быстро, но я бы тоже сказал, что это бесполезно сложно. Он пытается быть решением «все-в-одном», которое работает для всех массивов, вложенных или нет. Фактически, он даже принимает больше, чем просто массивы, как входные данные и все еще пытается дать «правильный» ответ.

Generics предлагают повторное использование

Мой ответ подойдет к проблеме по-разному. Я начну с общей arrayCompare процедуры, которая касается только перехода через массивы. Оттуда мы построим другие основные функции сравнения, например, arrayEqual и arrayDeepEqual т. Д.

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

Как предполагает тип, arrayCompare используется функция сравнения f , и два входных массива, xs и ys . По большей части все, что мы делаем, это вызов f (x) (y) для каждого элемента входных массивов. Мы возвращаемся раньше, false если пользовательские f возвращения false — благодаря && оценке короткого замыкания. Таким образом, да, это означает, что компаратор может остановить итерацию раньше и предотвратить цикл через остальную часть входного массива, когда это не нужно.

Строгое сравнение

Затем, используя нашу arrayCompare функцию, мы можем легко создавать другие функции, которые могут потребоваться. Мы начнем с элементарного arrayEqual .

Просто как тот. arrayEqual можно определить с arrayCompare помощью функции сравнения, которая сравнивается a с b использованием === (для строгого равенства).

Читайте также:  Infrasonic quartet windows 10

Обратите внимание, что мы также определяем equal как свою собственную функцию. Это подчеркивает роль arrayCompare функции более высокого порядка для использования нашего первого компаратора порядка в контексте другого типа данных (Array).

Свободное сравнение

Мы могли бы так же легко определить, arrayLooseEqual используя == вместо этого. Теперь, сравнивая 1 (Number) с ‘1’ (String), результат будет true .

Глубокое сравнение (рекурсивное)

Вы, наверное, заметили, что это только мелкое сравнение. Разумеется, решение Томаша — «Правильный путь», потому что оно подразумевает глубокое сравнение, верно?

Ну, наша arrayCompare процедура достаточно универсальна, чтобы использовать ее таким образом, чтобы сделать глубокий тест на равномерность .

Просто как тот. Мы строим глубокий компаратор, используя другую функцию более высокого порядка. На этот раз мы завершаем arrayCompare использование пользовательского компаратора, который будет проверять, являются ли a и b являются ли массивы. Если это так, повторно применяйте arrayDeepCompare сравнение в противном случае a и b к указанному пользователем компаратору ( f ). Это позволяет нам сохранять глубокое сравнительное поведение отдельно от того, как мы фактически сравниваем отдельные элементы. Т.е., как в примере выше показывает, мы можем глубоко сравнить с помощью equal , looseEqual или любой другой компаратор мы делаем.

Потому что arrayDeepCompare это карри, мы можем частично применить его так же, как и в предыдущих примерах

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

Сравнение объектов (пример)

Теперь, если у вас есть массив объектов или что-то еще? Возможно, вы хотите считать эти массивы «равными», если каждый объект имеет одинаковое id значение .

Просто как тот. Здесь я использовал объекты Vanilla JS, но этот тип компаратора мог работать для любого типа объекта; даже ваши пользовательские объекты. Решение Томаша должно быть полностью переработано для поддержки такого теста равенства

Глубокий массив с объектами? Не проблема. Мы создали универсальные универсальные функции, поэтому они будут работать в самых разных вариантах использования.

Произвольное сравнение (пример)

Или что, если вы хотите сделать какой-то другой вид совершенно произвольного сравнения? Может быть, я хочу знать, если каждый x больше, чем каждый y .

Меньше — больше

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

С легкостью, мы можем точно определить , как мы хотим , два массива , чтобы быть сравнен — мелкое, глубокое, строгое, свободное, некоторое свойство объекта, или некоторые произвольные вычислений, или любую комбинацию из них — все с помощью одной процедуры , arrayCompare . Может, даже придумать RegExp компаратора! Я знаю, как дети любят эти регулярные выражения .

Это самый быстрый? Нету. Но, вероятно, это тоже не обязательно. Если скорость является единственной метрикой, используемой для измерения качества нашего кода, очень хороший код будет выброшен — вот почему я называю этот подход «Практический путь» . Или , может быть более справедливым, Практический подход. Это описание подходит для этого ответа, потому что я не говорю, что этот ответ практичен только в сравнении с другим ответом; это объективно верно. Мы достигли высокой степени практичности с очень маленьким кодом, о котором очень легко рассуждать. Никакой другой код не может сказать, что мы не заработали это описание.

Это делает это «правильным» решением для вас? Это вам решать. И никто другой не может этого сделать для вас; только вы знаете, что ваши потребности. Почти во всех случаях я ценю простой, практичный и универсальный код с умным и быстрым видом. То, что вы цените, может отличаться, поэтому выберите то, что работает для вас.

редактировать

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

Ссылка на основную публикацию
Создать новую электронную почту на яндексе бесплатно
Всем привет! С вами снова я, Алексей. В этом посте я расскажу вам о том, как создать электронную почту на...
Сколько человек сидит в одноклассниках
Mail.Ru Group исследовала и сравнила аудитории самых популярных в России социальных сетей — «Одноклассники», «Мой Мир», «ВКонтакте», Facebook и Twitter....
Сколько четырехзначных чисел можно составить из нечетных
Условие Решение 1 Решение 2 Решение 3 Поиск в решебнике Популярные решебники Издатель: Н. Я. Виленкин, В. И. Жохов, А....
Создать канал на ютубе регистрация бесплатно
Добрый день, уважаемые читатели и гости моего блога! Если вы попали на эту статью, значит хотите узнать, как зарегистрироваться в...
Adblock detector