Как удалить повторяющиеся объекты из массива JavaScript

Для удаления дубликатов примитивов используйте Set, для объектов с одинаковым id – Map. Если дубликат определяется всеми полями, задайте функцию сравнения. Вы разберетесь, какой метод подходит под ваш тип массива и ключ сравнения. Примеры показывают работу filter, reduce и сравнение вложенных структур.

Каждый способ сохраняет выбранный объект целиком, вместе с остальными полями.

Удаление дубликатов из массива примитивов

Массив строк может содержать несколько одинаковых названий книг. Set оставит только первое вхождение каждого значения, сохранив порядок.

const strings = [
    "My Sister the Serial Killer",
    "Educated",
    "My Sister the Serial Killer"
];

const uniqueStrings = [...new Set(strings)];
console.log(JSON.stringify(uniqueStrings));
// ["My Sister the Serial Killer","Educated"]

Запись Array.from(new Set(strings)) дает такой же результат.

Оба варианта создают новый массив, не меняя исходный.

Set подходит для строк, чисел, логических значений и других примитивов. Значения 1 и "1" он считает разными. Повторяющиеся значения NaN Set объединяет, а 0 и -0 считает одинаковыми.

Альтернатива через filter и indexOf

Метод indexOf возвращает индекс первого вхождения искомого значения. Метод filter оставляет элемент, если текущий индекс совпадает с первым.

const filteredStrings = strings.filter((item, index) => {
    // Оставляем только первое вхождение строки.
    return strings.indexOf(item) === index;
});

console.log(JSON.stringify(filteredStrings));
// ["My Sister the Serial Killer","Educated"]

Такой поиск занимает O(n²) времени в худшем случае. Для каждого элемента indexOf заново просматривает часть исходного массива. Кроме того, indexOf не находит NaN: этот вариант удалит все его вхождения.

Выбирайте Set для обычного удаления дублей из массива примитивов.

При типичной реализации на хеш-таблице обработка занимает O(n) времени. Стандарт JavaScript не гарантирует именно хеш-таблицу, поэтому это оценка реализации, а не универсальная гарантия.

Почему filter и indexOf не сравнивают поля объектов

Два отдельно созданных объекта могут содержать одинаковые свойства и значения. Оператор строгого равенства при этом вернет false.

const a = {
    name: "My Sister the Serial Killer",
    author: "Oyinkan Braithwaite"
};

const b = {
    name: "My Sister the Serial Killer",
    author: "Oyinkan Braithwaite"
};

console.log(a === b); // false
console.log([a, b].indexOf(b)); // 1
console.log([a].indexOf(b)); // -1
console.log(new Set([a, b, a]).size); // 2

Поэтому равными будут только ссылки на один и тот же объект. Метод indexOf найдет переданный объект только по той же ссылке. Set тоже удалит повторную ссылку на a, но сохранит отдельный объект b.

Чтобы убрать повторяющиеся объекты из массива JavaScript, определите правило равенства.

Например, сравнивайте только id либо проверяйте все поля объекта. Эти правила решают разные задачи и дают разные результаты.

Удаление дубликатов объектов по ключу id

При сравнении по id остальные поля не влияют на уникальность. Сначала решите, какую запись оставить, если названия или другие значения различаются.

const books = [
    { id: 1, name: "Первое название", available: false },
    { id: 2, name: "Другая книга", available: true },
    { id: 1, name: "Новое название", available: true }
];

Map оставляет последний объект с одинаковым ключом

Передайте в Map пары из идентификатора и самого объекта. Повторный ключ заменит значение, сохранив позицию первого появления ключа.

const lastById = [
    ...new Map(books.map(book => [book.id, book])).values()
];

console.log(JSON.stringify(lastById));
// [{"id":1,"name":"Новое название","available":true},{"id":2,"name":"Другая книга","available":true}]

Результат содержит 2 объекта со всеми исходными полями. Запись с id 1 взята из конца массива, но стоит первой.

Map сохраняет порядок первого появления ключей, а не последних объектов.

При типичной хеш-реализации этот способ занимает O(n) времени. Дополнительная память тоже составляет O(n), включая пары и результат.

filter и findIndex оставляют первый объект

Метод findIndex позволяет задать собственное условие поиска. Оставьте объект, если его позиция совпадает с первым найденным id.

const firstById = books.filter((book, index, array) =>
    array.findIndex(candidate => candidate.id === book.id) === index
);

console.log(JSON.stringify(firstById));
// [{"id":1,"name":"Первое название","available":false},{"id":2,"name":"Другая книга","available":true}]

Способ сохраняет первый объект и порядок оставшихся записей. В худшем случае вложенные проходы требуют O(n²) времени.

Используйте этот вариант для небольших массивов или сложного условия сравнения.

reduce и Set сохраняют первую запись за один проход

Метод reduce накапливает результат, а Set хранит встреченные идентификаторы. Функция пропускает объект, если такой ключ уже встречался.

function uniqueById(items) {
    const seen = new Set();

    return items.reduce((result, item) => {
        if (!seen.has(item.id)) {
            seen.add(item.id);
            result.push(item);
        }
        return result;
    }, []);
}

const reducedBooks = uniqueById(books);
console.log(JSON.stringify(reducedBooks));
// [{"id":1,"name":"Первое название","available":false},{"id":2,"name":"Другая книга","available":true}]

Функция сохраняет первый экземпляр, его поля и исходный порядок. При типичной хеш-реализации Set оценка времени составляет O(n). Накопитель меняется внутри функции, но исходный массив остается прежним.

Проверьте наличие id у входных записей перед удалением дубликатов.

Map и Set объединят отсутствующие идентификаторы под ключом undefined. Число 1 и строка "1" останутся разными ключами. Пример с findIndex использует строгое равенство, поэтому повторяющиеся id со значением NaN он не обработает корректно.

Сравнение объектов по всем полям

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

function shallowEqual(current, comparison) {
    const keys = Object.keys(current);
    if (keys.length !== Object.keys(comparison).length) {
        return false;
    }

    return keys.every(key =>
        Object.hasOwn(comparison, key) &&
        current[key] === comparison[key]
    );
}

function removeDuplicates(arr) {
    return arr.filter((current, index) =>
        arr.findIndex(comparison =>
            shallowEqual(current, comparison)
        ) === index
    );
}

const uniqueBooks = removeDuplicates([a, b]);
console.log(JSON.stringify(uniqueBooks));
console.log(uniqueBooks[0] === a);

Запустите код после объявления объектов a и b. Функция вернет массив с первым объектом, а сравнение ссылок даст true.

[{"name":"My Sister the Serial Killer","author":"Oyinkan Braithwaite"}]
true

Порядок ключей внутри объектов не влияет на эту проверку. Object.hasOwn подтверждает, что ключ принадлежит самому сравниваемому объекту.

Функция рассчитана на обычные ненулевые объекты без специальных типов.

Object.keys учитывает только собственные перечисляемые строковые ключи. Символьные и неперечисляемые свойства эта проверка не сравнивает.

Ограничения поверхностного сравнения и скорость

Проверка через current[key] === comparison[key] сравнивает вложенные объекты по ссылке. Поэтому разные вложенные объекты с одинаковым содержимым не пройдут проверку. Одна и та же вложенная ссылка, напротив, совпадет.

console.log(shallowEqual(
    { details: { pages: 200 } },
    { details: { pages: 200 } }
)); // false

Для n объектов с k полями худшая оценка составляет O(n² · k). Проверка NaN через строгое равенство также возвращает false. Не применяйте этот вариант к записям с NaN без изменения правила сравнения.

Попарная проверка плохо подходит для больших массивов. Если задача допускает сравнение по идентификатору, используйте Map или Set.

Вложенные объекты и готовые функции Lodash

Глубокое сравнение проверяет содержимое вложенных объектов и массивов. Если проект уже использует Lodash, примените uniqWith вместе с isEqual.

В примере библиотека уже подключена под именем _. Метод uniqWith сохраняет первый объект из каждой группы совпадений.

const nestedBooks = [
    { id: 1, details: { tags: ["fiction"], pages: 200 } },
    { id: 1, details: { pages: 200, tags: ["fiction"] } },
    { id: 1, details: { tags: ["fiction"], pages: 250 } }
];

const deepUnique = _.uniqWith(nestedBooks, _.isEqual);

console.log(deepUnique.length); // 2
console.log(deepUnique[0] === nestedBooks[0]); // true
console.log(deepUnique[1].details.pages); // 250

Первый и второй объекты совпадают, несмотря на порядок полей details. Третий объект остается, поскольку значение pages отличается.

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

Для сравнения по одному полю подойдет _.uniqBy(books, "id"). Этот метод тоже оставляет первый объект с каждым значением id. Правила функций описаны в документации uniqBy и uniqWith.

Глубокая проверка дороже сравнения простых идентификаторов. В худшем случае uniqWith выполняет квадратичное количество сравнений. Стоимость каждого сравнения зависит от размера вложенных данных.

Удаление дубликатов через JSON.stringify

JSON.stringify превращает объект в строку, которую можно хранить в Set. Такой способ подходит только для данных с заранее известной структурой.

function uniqueByJSON(items) {
    const seen = new Set();

    return items.filter(item => {
        const key = JSON.stringify(item);
        if (seen.has(key)) return false;
        seen.add(key);
        return true;
    });
}

console.log(uniqueByJSON([a, b]).length); // 1
console.log(uniqueByJSON([a, b])[0] === a); // true

Функция сохраняет первый исходный объект, не создавая его JSON-копию.

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

  • Порядок добавления обычных строковых ключей влияет на строку. Объекты { a: 1, b: 2 } и { b: 2, a: 1 } дадут разные строки.
  • JSON.stringify пропускает свойства объектов со значениями undefined и функциями. Поэтому { a: undefined } и {} совпадут после сериализации.
  • В массиве undefined и функции превращаются в null.
  • Date сериализуется в строку и теряет отличие от такой же строки.
  • Циклические ссылки вызывают ошибку. Обычная сериализация BigInt тоже завершается ошибкой.

Подробное поведение описывает документация JSON.stringify. Не используйте сериализацию как универсальную замену глубокому сравнению.

Какой способ удаления дубликатов выбрать

Выбирайте метод по правилу равенства и размеру входных данных. В таблице n обозначает количество элементов, k – число поверхностных полей. Обозначение s описывает длину JSON-строки, c – стоимость глубокого сравнения.

МетодДля каких данныхВремяКакой экземпляр остаетсяПорядок результата
SetПримитивы или повторные ссылкиОбычно O(n)*Первое вхождениеПо первым вхождениям
filter + indexOfПримитивы без NaNO(n²)ПервыйИсходный
Map по idОбъекты с ключомОбычно O(n)*ПоследнийПо первым появлениям ключей
filter + findIndex по idОбъекты с ключом без NaNO(n²)ПервыйИсходный
reduce + Set по idОбъекты с ключомОбычно O(n)*ПервыйИсходный
removeDuplicatesОбычные объекты с примитивными полями без NaNO(n² · k)ПервыйИсходный
Lodash uniqWith + isEqualВ том числе вложенные объектыДо O(n² · c)ПервыйИсходный
JSON.stringify + SetОграниченные JSON-совместимые структурыОбычно O(n · s)*ПервыйИсходный

*Оценки для Map и Set предполагают типичную хеш-реализацию. Остальные оценки описывают худший случай для показанных алгоритмов.

Для больших массивов записей с id выбирайте Map или Set. Map удобен, если последняя запись должна заменить предыдущую целиком. reduce с Set оставляет первую запись, сохраняя ее поля. Если важны все вложенные значения, задайте глубокое сравнение.

Все показанные способы создают новый массив и сохраняют ссылки на объекты. Изменение поля в результате изменит тот же объект в исходном массиве.

Для независимых объектов нужна отдельная операция копирования.

Совет от нашей редакции: закрепите правило равенства небольшим тестом. Добавьте 2 записи с одинаковым id и разными полями. Тест должен проверять, какая запись остается, и порядок результата.

Комментарии

Оставьте свой комментарий
И
Иван

Работает исправно и без внесения правок. Сэкономлено несколько @опочасов 😉

И
Иван

Безграничное спасибо за функцию!