Effizienter Weg, um entfernen Sie ein element aus einem array in Actionscript 3

Ich habe ein array von Objekten. Jedes Objekt hat eine Eigenschaft mit dem Namen name. Ich will effizient entfernen Sie ein Objekt mit einem bestimmten Namen aus dem array. Ist dies der BESTE Weg?

  private function RemoveSpoke(Name:String):void {
    var Temp:Array=new Array;
    for each (var S:Object in Spokes) {
      if (S.Name!=Name) {
        Temp.push(S);
      }
    }
    Spokes=Temp;
  }

InformationsquelleAutor Joshua | 2010-05-26

12

Wenn Sie bereit sind, verbringen einige Speicher auf eine lookup-Tabelle, diese werden dann ziemlich schnell:
```
private function remove( data:Array, objectTable:Object, name:String):void {
var index:int = data.indexOf( objectTable[name] );
objectTable[name] = null;
data.splice( index, 1 );
}
```
Den test für diese sieht wie folgt aus:
```
private function test():void{

var lookup:Object = {};
var Spokes:Array = [];
for ( var i:int = 0; i < 1000; i++ )
{
    var obj:Object = { name: (Math.random()*0xffffff).toString(16), someOtherProperty:"blah" };
    if ( lookup[ obj.name ] == null )
    {
        lookup[ obj.name ] = obj;
        Spokes.push( obj );
    }
}

var t:int = getTimer();
for ( var i:int = 0; i < 500; i++ )
{
    var test:Object = Spokes[int(Math.random()*Spokes.length)];
    remove(Spokes,lookup,test.name)
}
trace( getTimer() - t );
```
}

Eine wichtige Sache über diese Lösung: es wird nur funktionieren, wenn jeder "name" ist einzigartig. Wenn es mehrere Objekte mit dem gleichen Namen der lookup-Tabelle wird scheitern, zumindest wenn Sie so gebaut.
interessant... so haben Sie grundsätzlich zwei Listen mit doppelte Daten... im Allgemeinen wäre es besser, nur die Verwendung von lookup-Tabellen und verzichten auf arrays für diese Situationen? das funktioniert nur, da das Objekt hat einen name - Eigenschaft oder die indexOf Methode sucht in jeder Eigenschaft mit dem Wert des Objekts?
Ja, wenn Sie dies nicht tun, müssen Sie das array für andere Zwecke (wie das Sortieren oder den Zugriff auf Elemente über index) in diesem Fall könnte man nur mit der lookup-Tabelle. indexOf sucht Instanzen eines Objekts. In diesem Fall ist es nicht die Verwendung von "name" für den Vergleich. Der name wird als hash in der lookup-Tabelle.
+1. Das ist clever. Auf einem nicht verwandten und unangebracht schimpfen, Sie haben zu lieben, wie die Menschen meckern Objekt zu langsam, wenn es oft die Schnellste option, wenn verwendet mit bedacht, und wenn es passt in die Lösung. Das sagte, ich würde persönlich gehen mit nur einem array eine lineare Suche und splice (und keine pre/post-Inkrement/Dekrement-Tricks in-the-loop), es sei denn, es ist eine tatsächliche und echte Notwendigkeit für diese zusätzliche Geschwindigkeit.

InformationsquelleAutor Quasimondo
10

myArray.splice(myArray.indexOf(myInstance), 1);

InformationsquelleAutor LeManu
5

Der Schnellste Weg wird sein:
```
function remove(array: Array, name: String): void {
  var n: int = array.length
  while(--n > -1) {
    if(name == array[n].name) {
      array.splice(n, 1)
      return
    }
   }
}

remove([{name: "hi"}], "hi")
```
Können Sie auch entfernen Sie die return-Anweisung, wenn Sie möchten, um loszuwerden, alle alements, dass entsprechend der gegebenen Prädikat.

Joa! Sie rock. Aber wird der Apparat in der Lage sein, um es noch schneller? 🙂
Ließ ich mich auf und vergleichen Sie Ihre "schnellsten" gegen mine und kommen mit schlechten Nachrichten: entfernen von 500 Elemente aus einem 1000-Elemente-array - Ihre 34 ms, mine 4ms 😉

InformationsquelleAutor Joa Ebert
1

Ich habe keine Daten, um es wieder, aber meine Vermutung ist, dass array.filter vielleicht die Schnellste.

Wenn du meinst so etwas wie dieses: var filterName:String = "irgendwas"; Spokes = Speichen.filter(function( element:*, index:int, arr:Array):Boolean { return (element.name != filterName);}); dann muss ich Sie enttäuschen.Es ist etwa 5x langsamer als Joa ' s und fast um den Faktor 30 langsamer als meine.
Haha. Sie Jungs betrügen! 😉 Ist array.filter mindestens der Schnellste für die Schleife / iterator-basierten Methoden?

InformationsquelleAutor James Ward
1

Im Allgemeinen sollten Sie lieber die alten for-Schleife über die "for each" und "für jeden" und Vektor, wenn Ihre Elemente sind vom gleichen Typ. Wenn die Leistung wirklich wichtig sollten Sie eine verlinkte Liste.

Check-out Grant Skinners Folien http://gskinner.com/talks/quick/ und Jackson Dunstan ' s Blog für mehr infos über Optimierung.

InformationsquelleAutor DieTapete
0

Wenn Euch das nichts ausmacht mit der ArrayCollection, was ist ein wrapper für die Array-Klasse, Sie könnte so etwas tun:
```
private function RemoveSpoke(Name:String, Spokes:Array):Array{
  var ac:ArrayCollection = new ArrayCollection(Spokes);
  for (var i:int=0, imax:int=ac.length; i<imax; i++) {
    if (Spokes[i].hasOwnProperty("Name") && Spokes[i].Name === Name) {
      ac.removeItemAt(i);
      return ac.source;
    }
  }
  return ac.source;
}
```
FYI ArrayCollection ist nur verfügbar in Flex
FYI Flex ist einer der tags auf die Frage.
Oh stimmt, hab ich Total verpasst.
Was ist der Punkt, der den Umschlag in der ArrayCollection? Sie konnte nur splice array direkt. Oder bin ich etwas fehlt?

InformationsquelleAutor Robusto
0

Könnten Sie auch ArrayCollection mit filteranzeige, um einen Blick in das gleiche Array-Objekt

InformationsquelleAutor simms2k
0

Vielleicht ist diese Technik (optimierte splice-Methode von CJ ' s) verbessern die vorgeschlagenen von Quasimondo:

http://cjcat.blogspot.com/2010/05/stardust-v11-with-fast-array-splicing_21.html

InformationsquelleAutor TurboHz
0

Hier ist eine effiziente Funktion in Bezug auf die Wiederverwendbarkeit, so dass Sie mehr tun, als das Filterelement entfernen. Es gibt den index oder -1, falls nicht gefunden.
```
Funktion searchByProp(arr:Array, prop:String, value:Object): int 
{ 
var item:Object; 
var n: int = arr.Länge; 
for(var i:int=n;i>0;i--) 
{ 
item = arr[i-1]; 
if(item.hasOwnProperty(prop)) 
if( Wert == Element[prop] ) 
return i-1; 
} 
return -1; 
} 
```
Es sieht aus wie die Formatierung entfernt, die Art von Vektor, aber ich denke, es ist "Objekt". Getestet habe ich es schnell und zumindest bei mir mit Vektor in diesem Fall ist tatsächlich langsamer. Ich denke, wenn Sie wollen, profitieren Sie von der Geschwindigkeit des Vektors sollten Sie auch ein echter Typ und nicht "Objekt".
Dank Quasi. Hast du test mit meiner Funktion? Es hat einen zusätzlichen bedingten ( hasOwnProperty ), die verlangsamen würde es aber Sinn machen, wenn du nicht sicher bist, wird das Objekt die Eigenschaft. Um es schneller zu entfernen. Aber der user gefragt, um Effizienz, und diese Funktion spricht an, dass in Bezug auf die Wiederverwendbarkeit.
Getestet habe ich es mit Joa Vorschlag, so die hasOwnProperty war nicht das Problem hier.

InformationsquelleAutor reelfernandes

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.