Javascript-Set vs. Array-Leistung

Es vielleicht, weil die Sets sind relativ neu in Javascript, aber ich habe nicht in der Lage zu finden einen Artikel, auf StackO oder irgendwo sonst, dass die Gespräche über den Unterschied in der Leistung zwischen den beiden in Javascript. Also, was ist der Unterschied, in Bezug auf die Leistung zwischen den beiden? Speziell, wenn es darum geht, entfernen, hinzufügen und überarbeiten.

Kommentar zu dem Problem
Sie können nicht verwenden Sie Synonym. So macht es sehr wenig Sinn, Sie zu vergleichen. Kommentarautor: zerkms
Sie reden über den Vergleich zwischen Set und [] oder {}? Kommentarautor: eithed
Hinzufügen und überarbeiten, machen Sie nicht viel Unterschied, entfernen und - vor allem - lookup einen Unterschied machen. Kommentarautor: Bergi
mögliche Duplikate von Javascript-ES6 computational - /Zeit-Komplexität von Kollektionen Kommentarautor: Bergi
@zerkms—streng, Array ' s sind nicht bestellt, aber Ihre Verwendung von einem index ermöglicht Ihnen so behandelt werden, als wenn Sie es sind. 😉 Die Reihenfolge der Werte in einer Menge gehalten werden, in der insertion order. Kommentarautor: RobG

InformationsquelleAutor der Frage neoflash | 2016-08-17

  1. 21

    BEOBACHTUNGEN:

    • Set-Operationen können verstanden werden als snapshots im Rahmen der Abwicklung stream.
    • Wir sind nicht, bevor eine endgültige zu ersetzen.
    • Die Elemente einer Set Klasse haben keine zugänglichen Indizes.
    • Set Klasse ist ein Array-Klasse ergänzen, nützlich in jenen Szenarien, in denen wir speichern müssen, eine Sammlung in der addition,
      Löschen, prüfen und iteration Operationen.

    Teile ich einige test der performance. Versuchen Sie, öffnen Sie Ihre Konsole und copypaste den code unten.

    Erstellen eines Arrays (125000) 

    var n = 125000;
var arr = Array.apply( null, Array( n ) ).map( ( x, i ) => i );
console.info( arr.length ); //125000

    1. Suchen eines Index

    Wir verglichen das hat Methode-Set mit Arrays indexOf:

    Array/indexOf (0.281 ms) | Set/hat (0.053 ms)

    //Helpers
var checkArr = ( arr, item ) => arr.indexOf( item ) !== -1;
var checkSet = ( set, item ) => set.has( item );

//Vars
var set, result;

console.time( 'timeTest' );
result = checkArr( arr, 123123 );
console.timeEnd( 'timeTest' );

set = new Set( arr );

console.time( 'timeTest' );
checkSet( set, 123123 );
console.timeEnd( 'timeTest' );

    2. Hinzufügen eines neuen Elements

    Vergleichen wir das hinzufügen und push-Methoden der Satz-und Array-Objekte bzw.:

    Array/push (1.612 ms) | Set/hinzufügen (0.006 ms)

    console.time( 'timeTest' );
arr.push( n + 1 );
console.timeEnd( 'timeTest' );

set = new Set( arr );

console.time( 'timeTest' );
set.add( n + 1 );
console.timeEnd( 'timeTest' );

console.info( arr.length ); //125001
console.info( set.size ); //125001

    3. Löschen eines Elements

    Beim löschen von Elementen, müssen wir im Hinterkopf behalten, Array und Set nicht starten unter gleichen Bedingungen. Array verfügt nicht über eine native Methode, also eine externe Funktion notwendig ist.

    Array/deleteFromArr (0.356 ms) | Set/entfernen (0.019 ms)

    var deleteFromArr = ( arr, item ) => {
    var i = arr.indexOf( item );
    i !== -1 && arr.splice( i, 1 );
};

console.time( 'timeTest' );
deleteFromArr( arr, 123123 );
console.timeEnd( 'timeTest' );

set = new Set( arr );

console.time( 'timeTest' );
set.delete( 123123 );
console.timeEnd( 'timeTest' );

    Lesen Sie den vollständigen Artikel hier

    InformationsquelleAutor der Antwort Daniel Eduardo Delgado Diaz

  2. 1

    Meine Beobachtung ist, dass ein Satz immer besser mit zwei Fallstricke für große arrays in den Sinn :

    a) Die Erstellung des Sets von Arrays muss getan werden, in einem for Schleife mit einem precached-Länge.

    langsam (z.B. 18ms) new Set(largeArray)

    schnell (z.B. 6ms)
    const SET = new Set();
    const L = largeArray.length;
    for(var i = 0; i<L; i++) { SET.add(largeArray[i]) }

    b) Iteration getan werden könnte, in der gleichen Weise, weil es auch schneller ist als ein for of loop ...

    Sehen https://jsfiddle.net/0j2gkae7/5/

    für einen real-life Vergleich
    difference(), intersection(), union() und uniq() ( + Ihre iteratee Gefährten etc.) mit 40.000 Elementen

    InformationsquelleAutor der Antwort sebilasse

  3. 0

    Ich habe vor kurzem lief dieser test gefunden und das Set viel besser als ein Array mit 1000 Elementen (etwa 10x die Vorgänge, die passieren könnte, in der gleichen Zeitrahmen). Und je nach browser entweder schlagen oder verloren zu widersprechen.hasOwnProperty in einer like-for-like-test.

    Set und Objekt "hat" Methode durchführen, was zu sein scheint amortisiert O(1), aber je nach browser-Implementierung einen einzigen Vorgang könnte länger dauern oder schneller.

    https://jsperf.com/set-has-vs-object-hasownproperty-vs-array-includes/1
    In Fall, dass Sie wollen, führen Sie Ihre eigenen tests mit verschiedenen Browsern/Umgebungen.

    InformationsquelleAutor der Antwort Zargold

  4. -4
    console.time("set")
var s = new Set()
for(var i = 0; i < 10000; i++)
  s.add(Math.random())
s.forEach(function(e){
  s.delete(e)
})
console.timeEnd("set")
console.time("array")
var s = new Array()
for(var i = 0; i < 10000; i++)
  s.push(Math.random())
s.forEach(function(e,i){
  s.splice(i)
})
console.timeEnd("array")

    Diese drei Operationen auf 10K items gab mir:

    set: 7.787ms
array: 2.388ms

    InformationsquelleAutor der Antwort jessh

Schreibe einen Kommentar