Как проверить является ли массив уникальным?

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

Простой и эффективный способ проверить, содержит ли массив только уникальные элементы - сравнить длину массива с длиной Set.

function isArrayUnique(arr) {
  return arr.length === new Set(arr).size;
}

// Примеры
console.log(isArrayUnique([1, 2, 3]));           // true
console.log(isArrayUnique([1, 2, 2, 3]));        // false
console.log(isArrayUnique(['a', 'b', 'c']));     // true
console.log(isArrayUnique(['a', 'b', 'a']));     // false

Это работает O(n) по времени и очень читаемо. Set автоматически удаляет дубликаты, поэтому если размер Set меньше, значит были дубликаты.

Для объектов и сложных типов

Set использует строгое сравнение (===), поэтому для объектов нужен другой подход.

function isArrayUniqueObjects(arr, key) {
  const seen = new Set();
  
  for (const item of arr) {
    const identifier = JSON.stringify(item[key]);
    if (seen.has(identifier)) {
      return false;
    }
    seen.add(identifier);
  }
  
  return true;
}

// Примеры
const users = [
  { id: 1, name: 'Alice' },
  { id: 2, name: 'Bob' },
  { id: 1, name: 'Alice' }
];

console.log(isArrayUniqueObjects(users, 'id')); // false

Использование Map для отслеживания индексов

Если нужно узнать, где находятся дубликаты, используй Map.

function findDuplicates(arr) {
  const seen = new Map();
  const duplicates = new Map();
  
  for (let i = 0; i < arr.length; i++) {
    if (seen.has(arr[i])) {
      if (!duplicates.has(arr[i])) {
        duplicates.set(arr[i], []);
      }
      duplicates.get(arr[i]).push(i);
    } else {
      seen.set(arr[i], i);
    }
  }
  
  return duplicates;
}

// Пример
const arr = [1, 2, 2, 3, 3, 3, 4];
const dups = findDuplicates(arr);
console.log(dups);
// Map {
//   2 => [2],
//   3 => [3, 4]
// }

Для TypeScript

function isArrayUnique<T extends number | string | symbol>(
  arr: T[]
): boolean {
  return arr.length === new Set(arr).size;
}

function isArrayUniqueBy<T>(
  arr: T[],
  selector: (item: T) => number | string | symbol
): boolean {
  const seen = new Set<number | string | symbol>();
  
  for (const item of arr) {
    const key = selector(item);
    if (seen.has(key)) {
      return false;
    }
    seen.add(key);
  }
  
  return true;
}

// Использование
const numbers: number[] = [1, 2, 3];
console.log(isArrayUnique(numbers)); // true

const users: User[] = [
  { id: 1, email: 'a@example.com' },
  { id: 2, email: 'b@example.com' }
];
console.log(isArrayUniqueBy(users, u => u.id));    // true
console.log(isArrayUniqueBy(users, u => u.email)); // true

Использование includes (не рекомендуется)

Этот способ менее эффективен, но можно встретить в старом коде.

function isArrayUniqueInclude(arr) {
  for (let i = 0; i < arr.length; i++) {
    if (arr.indexOf(arr[i]) !== i) {
      return false;
    }
  }
  return true;
}

// Работает, но O(n^2) по времени
// Избегай для больших массивов!

Производительность

// Тест производительности
function benchmark(fn, arr, iterations = 1000) {
  const start = performance.now();
  for (let i = 0; i < iterations; i++) {
    fn(arr);
  }
  return performance.now() - start;
}

const largeArray = Array.from({ length: 10000 }, (_, i) => i % 5000);

console.log('Set approach:', benchmark(isArrayUnique, largeArray)); // ~0.1ms
console.log('indexOf:', benchmark(isArrayUniqueInclude, largeArray)); // ~100ms

Set подход в 1000 раз быстрее на больших массивах!

Практические рекомендации

1. Для примитивов - используй Set (самый быстрый)
2. Для объектов - используй isArrayUniqueBy с selector функцией
3. Для поиска дубликатов - используй Map
4. Для сложных условий - используй Set с custom key функцией
5. Избегай indexOf - слишком медленно на больших массивах

Основное правило: Set всегда быстрее, чем indexOf для проверки уникальности.