Moyen plus efficace pour supprimer un élément d'un tableau en Actionscript 3

J'ai un tableau d'objets. Chaque objet a une propriété appelée nom. Je veux supprimer efficacement un objet avec un nom particulier à partir du tableau. Est-ce la MEILLEURE façon de faire?

  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

Si vous êtes prêt à dépenser un peu de mémoire sur une table de correspondance, ce sera assez rapide:
```
private function remove( data:Array, objectTable:Object, name:String):void {
var index:int = data.indexOf( objectTable[name] );
objectTable[name] = null;
data.splice( index, 1 );
}
```
Le test pour cette ressemble à ceci:
```
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 );
```
}
- Une chose importante à propos de cette solution: il ne fonctionne que si chaque "nom" est unique. S'il y a plusieurs objets avec le même nom de la table de recherche échoue, au moins si elle est construite comme cela.
- intéressant... donc en gros, vous avez deux listes de données en double... en général, il serait mieux d'utiliser les tables de recherche et de renoncer aux tableaux pour ces situations? cela fonctionne tout simplement parce que l'objet a une name de la propriété ou de la indexOf méthode recherche dans tous les biens de la valeur de l'objet?
- Oui, si vous n'avez pas besoin de la matrice à d'autres fins (comme le tri ou d'accéder à des éléments par index) dans ce cas, vous pouvez simplement utiliser la table de recherche. indexOf trouve des occurrences d'un objet. Dans ce cas, il n'utilise pas de "nom" pour la comparaison. Le nom est utilisé comme le hachage dans la table de recherche.
- +1. Ce qui est intelligent. Sur un autre et injustifiées pour le délire, vous avez de l'amour comment les gens chienne au sujet de l'Objet de la lenteur, lorsque c'est souvent l'option la plus rapide si elle est utilisée à bon escient et si elle s'inscrit dans la solution. Cela dit, je n'irais personnellement avec juste un tableau, un linéaire de recherche et splice (et pas de pré/post incrémentation/décrémentation de la ruse dans la boucle), à moins qu'il existe une véritable et réel besoin de cette vitesse supplémentaire.
InformationsquelleAutor Quasimondo
10

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

InformationsquelleAutor LeManu
5

Le moyen le plus rapide sera présent:
```
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")
```
Vous pouvez également supprimer l'instruction de retour si vous voulez vous débarrasser de tous les alements qui correspondent le prédicat.
- Joa! Vous rock. Mais Apparat être en mesure de le faire encore plus vite? 🙂
- Je me suis permis de comparer votre "rapide" à l'encontre de la mine et de venir avec de mauvaises nouvelles: la suppression de 500 éléments de 1000 éléments de la matrice de la vôtre 34 ms, mine de 4ms 😉
InformationsquelleAutor Joa Ebert
1

Je n'ai pas de données à sauvegarder, mais ma conjecture est que tableau.filtre pourrait être le plus rapide.
- Si vous voulez dire quelque chose comme ceci: var filterName:String = "quelque chose"; Rayons = Rayons.filter(function( element:*, index:int, arr:Array):Boolean { return (élément.nom != filterName);}); ensuite, je dois vous décevoir.Il est environ 5 fois plus lent que Joa et près de 30 fois plus lent que le mien.
- Haha. Les gars, vous trichez! 😉 Est la matrice.filtre au moins le plus rapide pour la boucle / itérateur base de méthodes?
InformationsquelleAutor James Ward
1

En général, vous devriez préférer la vieille pour la boucle "pour chaque" et "pour chaque" et l'utilisation de Vecteur si vos éléments sont du même type. Si la performance est vraiment important que vous devriez considérer l'utilisation d'une liste liée.

Découvrez Subvention Skinners diapositives http://gskinner.com/talks/quick/ et Jackson Dunstan Blog pour plus d'infos sur l'optimisation.

InformationsquelleAutor DieTapete
0

Si vous n'avez pas l'esprit en utilisant le type arraycollection, qui est un wrapper pour la classe Array, vous pourriez faire quelque chose comme ceci:
```
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;
}
```
- Pour info type arraycollection est uniquement disponible en Flex
- Pour info Flex est l'un des balises sur la question.
- Oh vrai, j'ai totalement raté celui-là.
- Quel est le point de l'enveloppant dans le type arraycollection? vous pouvez simplement épissure le tableau directement. Ou ai-je raté quelque chose?
InformationsquelleAutor Robusto
0

Vous pouvez également utiliser de type arraycollection avec un filterFunction pour obtenir une vue sur le même objet Array

InformationsquelleAutor simms2k
0

Peut-être cette technique (optimisé épissure méthode par CJ) vont améliorer encore celui proposé par Quasimondo:

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

InformationsquelleAutor TurboHz
0

Voici un fonctionnement efficace en termes de réutilisabilité, vous permettant de faire plus que de supprimer l'élément. Il renvoie l'index, ou -1 si elle ne trouve pas.
```
fonction searchByProp(arr:Array, prop:Chaîne de valeur:Objet): int 
{ 
var item:Object; 
var n: int = arr.longueur; 
for(var i:int=n;i>0;i--) 
{ 
item = arr[i-1]; 
si(item.hasOwnProperty(prop)) 
if( valeur == item[prop] ) 
de retour i-1; 
} 
return -1; 
} 
```
- Il ressemble à la mise en forme supprimé le type de vecteur, mais je suppose que c'est "l'Objet". Je l'ai testé rapidement, et au moins pour moi, en utilisant le Vecteur dans ce cas est en fait plus lentement. Je pense que si vous voulez profiter de la vitesse de Vecteur vous devez également utiliser un type réel et non "Objet".
- Grâce Quasi. Avez-vous testé à l'aide de ma fonction? Il a rajouté une conditionnelle ( hasOwnProperty ) qui permettrait de ralentir, mais de sens que si vous n'êtes pas sûr de l'objet aura la propriété. Pour le rendre plus rapide de le supprimer. Mais l'utilisateur a demandé à propos de l'efficacité, et cette fonction parle en termes de réutilisabilité.
- Je l'ai testé avec Joa de la proposition, de sorte que le hasOwnProperty n'était pas la question ici.
InformationsquelleAutor reelfernandes

Vous devez vous connecter pour publier un commentaire.