javaScript bietet zwei leistungsstarke Datenstrukturen zum Speichern von Sätzen: set und array . Während beide mehrere Werte speichern können, machen ihre einzigartigen Funktionen sie für verschiedene Szenarien besser geeignet. Lassen Sie uns untersuchen, wann und warum einer über den anderen ausgewählt wird.

1. der eindeutige Wert maßgeblich

Das bekannteste Merkmal von

set ist die automatische Verarbeitung von Duplikaten.

// 数组允许重复
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]

Element Check Performance

set

Bietet schnellere Suchzeiten, um zu überprüfen, ob ein Element existiert.

const largearray = array.from ({Länge: 1000000}, (_, i) => i); const largeset = new set (largearray); // Array -Suche console.time ('Array include'); console.log (largearray.includes (999999)); console.timeend ('Array include'); // Suche console.time ('set has'); console.log (largeset.has (9999999)); console.timeend ('set has'); // Set ist offensichtlich schneller, da es intern Hash -Tabellen verwendet

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 明显更快，因为它内部使用哈希表

verfügbare Methoden und Operationen

array

bietet mehr integrierte Methoden für die Datenmanipulation, während set sich auf die Einzigartigkeitsmanagement konzentriert.

// Array -Methode const arr = [1, 2, 3, 4, 5]; arr.push (6); arr.pop (); arr.unshift (0); arr.shift (); arr.SPLICE (2, 1, 'neu'); arr.lice (1, 3); arr.map (x => x * 2); arr.filter (x => x> 2); Arr.ReDuce ((a, b) => a b); // Methode festlegen const set = neuer set ([1, 2, 3, 4, 5]); set.add (6); set.delete (6); set.has (5); set.clear (); // alle Werte löschen

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 明显更快，因为它内部使用哈希表

Sequenz und Index Access

array

behält die Einfügungsreihenfolge und bietet indexbasierte Zugriff, während set nur die Einfügungsreihenfolge beibehält.

// Array Indexzugriff const arr = ['a', 'b', 'c']; console.log (arr [0]); console.log (arr [1]); arr [1] = 'x'; // Set hat keinen Indexzugriff const set = new set (['a', 'b', 'c']); console.log ([... festgelegt] [0]); // Direkte Änderung von index

// 数组索引访问
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]); // 需要先转换为数组
// 不允许直接修改索引

Memory Usage

set

verwendet normalerweise mehr Gedächtnis als array , bietet aber schnellere Nachschläge.

// Speichervergleich (grobe Beispiel) const numbers = array.from ({Länge: 1000}, (_, i) => i); // Array -Speicher const arr = [... Zahlen]; console.log (process.memoryusage (). häufiger); // Speicher festlegen const set = new set (nummern); console.log (process.memoryusage (). häufiger); // Aufgrund der Hash -Tabellenstruktur verwendet gesetzt normalerweise mehr Speicher

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 明显更快，因为它内部使用哈希表

häufig verwendete Fälle
Wann verwendet Array:

// 1. Wenn Reihenfolge und Indexzugriff wichtig sind const playlist = ['Song1.mp3', 'Song2.mp3', 'Song3.mp3']; const currentRack = Playlist [currentIndex]; // 2. Wenn Sie eine Array -Methode benötigen const nummern = [1, 2, 3, 4, 5]; const doubled = numbers.map (x => x * 2); const sum = numbers.Reduce ((a, b) => a b, 0); // 3. Wenn wiederholte Werte akzeptabel oder erforderlich sind const stimmt = ['yes', 'nein', 'yes', 'yes', 'yes', 'nein']; const yesvotes = stimmen.filter (stimmen => stimmen === 'Ja'). Länge;

// 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. Beim Verfolgen einzigartiger Werte const uniquevisitoren = new set (); Funktion LOGVISITOR (UserID) { uniquevisitors.add (userId); console.log (`Gesamt eindeutige Besucher: $ {uniquevisitors.size}`); } // 2. Wird für Schnellsuchvorgänge verwendet const erlaubte = new set (['user1', 'user2', 'user3']); Funktion checkAccess (userId) { return erlaubteUsers.has (userId); } // 3.. Wird zum Löschen von Duplikaten verwendet Funktion getuniqueHashTags (Beiträge) { const uniquetags = new set (); posts.foreach (post => { post.hashtags.foreach (tag => uniquetags.add (Tag)); }); return [... Einsachen]; }

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

konvertieren

Sie können leicht zwischen

set

und array nach Bedarf konvertieren.

// Array zu festlegen const arr = [1, 2, 2, 3, 3, 4]; const set = new set (arr); // auf Array einstellen - drei Methoden const back1 = [... set]; const back2 = array.from (set); const Back3 = array.from (set.Values ​​()); // für die Array -Deduplizierung verwendet const dedicated = [... New 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)];

select

array

wenn du Folgendes brauchst:

indexbasierte access

• Umfangreiche Array -Methoden (Karte, Reduzierung, Filter usw.)
• repote value
• Gedächtniseffizienz
• traditionelles iteratives Modell
set

Wenn Sie die folgenden Situationen benötigen:

nur eindeutig Wert

Schnelle Suchoperation
Einfaches add/löschen Operation
behalten Sie die Liste der eindeutigen Elemente
schnelle Deduplication
• Denken Sie daran, dass Sie jederzeit zwischen den beiden Typen konvertieren können. Wählen Sie also die aus, die Ihren aktuellen Anforderungen am besten entspricht.