javaScript fournit deux structures de données puissantes pour stocker les ensembles: set et array . Bien que les deux puissent stocker plusieurs valeurs, leurs fonctionnalités uniques les rendent plus adaptés à différents scénarios. Explorons quand et pourquoi l'un est choisi par rapport à l'autre.

1. la valeur unique par défaut

La caractéristique la plus importante de

set est son traitement automatique des doublons.

// 数组允许重复
const arr = [1, 2, 2, 3, 3, 4];
console.log(arr); // [1, 2, 2, 3, 3, 4]

// Set 自动删除重复项
const set = new Set([1, 2, 2, 3, 3, 4]);
console.log([...set]); // [1, 2, 3, 4]

// 使用 Set 从数组中删除重复项
const uniqueArray = [...new Set(arr)];
console.log(uniqueArray); // [1, 2, 3, 4]

Vérification des éléments Performance

set

fournit des temps de recherche plus rapides pour vérifier si un élément existe.

const LargeArray = array.from ({longueur: 1000000}, (_, i) => i); const largeseSet = nouveau set (LargeArray); // Recherche de tableau Console.Time ('Array Inclure'); Console.log (LargeArray.Cludes (999999)); Console.Timeend ('Array Inclure'); // Définir la recherche Console.Time ('Set Has'); Console.log (Largeset.Has (999999)); Console.Timeend ('Set Has'); // set est évidemment plus rapide car il utilise des tables de hash en interne

const largeArray = Array.from({ length: 1000000 }, (_, i) => i);
const largeSet = new Set(largeArray);

// 数组查找
console.time('Array includes');
console.log(largeArray.includes(999999));
console.timeEnd('Array includes');

// Set 查找
console.time('Set has');
console.log(largeSet.has(999999));
console.timeEnd('Set has');

// Set 明显更快，因为它内部使用哈希表

méthodes et opérations disponibles

array

fournit des méthodes plus intégrées pour la manipulation des données, tandis que set se concentre sur la gestion de l'unicité.

// Méthode du tableau const Arr = [1, 2, 3, 4, 5]; arr.push (6); arr.pop (); arr.unshift (0); arr.shift (); Arr.splice (2, 1, «nouveau»); Arr.slice (1, 3); arr.map (x => x * 2); arr.filter (x => x> 2); arr.reduce ((a, b) => a b); // Définir la méthode const set = nouveau set ([1, 2, 3, 4, 5]); set.add (6); set.delete (6); set.has (5); set.clear ();

// 数组方法
const arr = [1, 2, 3, 4, 5];
arr.push(6);                    // 添加到末尾
arr.pop();                      // 从末尾移除
arr.unshift(0);                 // 添加到开头
arr.shift();                    // 从开头移除
arr.splice(2, 1, 'new');       // 替换元素
arr.slice(1, 3);               // 提取部分
arr.map(x => x * 2);           // 转换元素
arr.filter(x => x > 2);        // 过滤元素
arr.reduce((a, b) => a   b);   // 归约为单个值

// Set 方法
const set = new Set([1, 2, 3, 4, 5]);
set.add(6);                    // 添加值
set.delete(6);                 // 删除值
set.has(5);                    // 检查是否存在
set.clear();                   // 删除所有值

4. array
maintient l'ordre d'insertion et fournit un accès basé sur l'index, tandis que

set

ne maintient que l'ordre d'insertion. // Accès à l'index du tableau const Arr = ['a', 'b', 'c']; console.log (arr [0]); console.log (arr [1]); arr [1] = 'x'; // Définir n'a pas d'accès à l'index const set = nouveau set (['a', 'b', 'c']); console.log ([... set] [0]); // La modification directe de l'index

n'est pas autorisée

// 数组索引访问
const arr = ['a', 'b', 'c'];
console.log(arr[0]);      // 'a'
console.log(arr[1]);      // 'b'
arr[1] = 'x';            // 直接修改

// Set 没有索引访问
const set = new Set(['a', 'b', 'c']);
console.log([...set][0]); // 需要先转换为数组
// 不允许直接修改索引

5. set
utilise généralement plus de mémoire que

array

, mais fournit des recherches plus rapides. // Comparaison de mémoire (exemple approximatif) const nombres = array.from ({longueur: 1000}, (_, i) => i); // Mémoire de tableau const arr = [... nombres]; console.log (process.MemoryUsage (). HeapUsed); // définir la mémoire const set = new Set (nombres); console.log (process.MemoryUsage (). HeapUsed); // En raison de la structure de la table de hash, Set utilise généralement plus de mémoire

// 内存比较（粗略示例）
const numbers = Array.from({ length: 1000 }, (_, i) => i);

// 数组内存
const arr = [...numbers];
console.log(process.memoryUsage().heapUsed);

// Set 内存
const set = new Set(numbers);
console.log(process.memoryUsage().heapUsed);
// 由于哈希表结构，Set 通常使用更多内存

6. Quand utiliser le Array:

// 1. Lorsque l'accès à l'ordre et à l'index sont importants const playlist = ['Song1.mp3', 'Song2.mp3', 'Song3.mp3']; const CurrentTrack = playList [currentIndex]; // 2. Lorsque vous avez besoin d'une méthode de tableau Nombres const = [1, 2, 3, 4, 5]; const Doubled = nombres.map (x => x * 2); const sum = nombres.reduce ((a, b) => a b, 0); // 3. Lorsque les valeurs répétées sont acceptables ou requises const votes = [«oui», «non», «oui», «oui», «oui», «non»]; const YesVotes = votes.filter (vote => vote === «Oui»). Length;

// 1. 当顺序和索引访问很重要时
const playlist = ['song1.mp3', 'song2.mp3', 'song3.mp3'];
const currentTrack = playlist[currentIndex];

// 2. 当您需要数组方法时
const numbers = [1, 2, 3, 4, 5];
const doubled = numbers.map(x => x * 2);
const sum = numbers.reduce((a, b) => a   b, 0);

// 3. 当重复值可以接受或需要时
const votes = ['yes', 'no', 'yes', 'yes', 'no'];
const yesVotes = votes.filter(vote => vote === 'yes').length;

// 1. Lors du suivi des valeurs uniques const uniquesiSitors = new Set (); fonction logvisitor (userId) { UniQuisiTors.Add (UserId); Console.log (`Total Visitors uniques: $ {UniQuavisitors.Size}`); } // 2. Utilisé pour les opérations de recherche rapide const les autorisations = new set (['user1', 'user2', 'user3']); Fonction CheckAccess (userId) { return allairsUsers.has (userId); } // 3. Utilisé pour supprimer des doublons fonction getUniqueHashtags (poteaux) { const uniquetags = new set (); postes.ForEach (post => { post.hashtags.ForEach (tag => uniquetags.add (tag)); }); return [... uniquetags]; }

// 1. 当跟踪唯一值时
const uniqueVisitors = new Set();
function logVisitor(userId) {
    uniqueVisitors.add(userId);
    console.log(`Total unique visitors: ${uniqueVisitors.size}`);
}

// 2. 用于快速查找操作
const allowedUsers = new Set(['user1', 'user2', 'user3']);
function checkAccess(userId) {
    return allowedUsers.has(userId);
}

// 3. 用于删除重复项
function getUniqueHashtags(posts) {
    const uniqueTags = new Set();
    posts.forEach(post => {
        post.hashtags.forEach(tag => uniqueTags.add(tag));
    });
    return [...uniqueTags];
}

set

et

array

au besoin. // tableau à définir const Arr = [1, 2, 2, 3, 3, 4]; const set = new Set (arr); // Défini sur Array - Trois méthodes const back1 = [... set]; const back2 = array.from (set); const back3 = array.from (set.values ​​()); // utilisé pour la déduplication du tableau const Dediated = [... nouveau set (arr)];

// 数组到 Set
const arr = [1, 2, 2, 3, 3, 4];
const set = new Set(arr);

// Set 到数组 - 三种方法
const back1 = [...set];
const back2 = Array.from(set);
const back3 = Array.from(set.values());

// 用于数组去重
const deduped = [...new Set(arr)];

array

Lorsque vous avez besoin de ce qui suit:

Access basé sur l'index

Méthodes de tableau étendues (carte, réduction, filtrer, etc.)

• répéter la valeur
• Efficacité de la mémoire
• modèle itératif traditionnel
set
• lorsque vous avez besoin des situations suivantes:

seule valeur unique Opération de recherche rapide

Add / supprimer l'opération
Gardez la liste des éléments uniques
Deduplication rapide
• N'oubliez pas que vous pouvez convertir entre les deux types à tout moment, alors choisissez celui qui convient le mieux à vos besoins actuels.