Flash as3如何删除数组中的重复项？

Question

嗨我只是在Flash中有一个名称（字符串）数组，我想确保删除数组中的任何重复项，或者至少每个数组中重复值的值只能执行一次函数。

Answer 1

更多猫剥皮的理论：

var a:Array = ["Tom", "John", "Susan", "Marie", "Tom", "John", "Tom", "Eva"]; 
a.sort(); 
var i:int = 0; 
while(i < a.length) { 
    while(i < a.length+1 && a[i] == a[i+1]) { 
     a.splice(i, 1); 
    } 
    i++; 
} 

Answer 2

很多方法。您可以对数组进行排序并对其进行迭代，忽略与先前迭代匹配的条目。或者您可以使用indexOf（）来搜索重复项。或者，您可以在数组上进行一次传递，构建一个字符串的字典（并忽略已有条目的键）。

这是字典的方式，每个唯一条目的内存成本为1布尔值，当你期望很多伪装时，内存容易记忆，而且速度很快。如果你有相对较少的愚弄，连续愚弄的排序+扑杀可能是更有效的

import flash.utils.Dictionary; 

var array:Array = ["harry","potter","ron","harry","snape","ginny","ron"]; 
var dict:Dictionary = new Dictionary(); 

for (var i:int = array.length-1; i>=0; --i) 
{ 
    var str:String = array[i] as String; 
    trace(str); 
    if (!dict[str]) 
    { 
     dict[str] = true; 
    } 
    else 
    { 
     array.splice(i,1); 
    } 
} 

dict = null; 


trace(array); 

这里有一个排序的方式，但要注意：这并不能维持秩序！你没有说这是否重要。但是，因为它使用快速排序，它往往具有O（N log N）性能加上一个额外的传递，除非你的数据当然是病态的。

var array:Array = ["harry","potter","ron","harry","ron","snape","ginny","ron"]; 

array.sort(); 
trace(array); 

for (var i:int = array.length-1; i>0; --i) 
{ 
    if (array[i]===array[i-1]) 
    { 
     array.splice(i,1); 
    } 
} 


trace(array); 

除了不指定是否顺序的问题，如果它的事项将受骗者的是左，你不说：在一个以最低的指数，或最后一个发现。如果那很重要，您需要重新排序字典示例以反向运行。我从最后开始，因为这样做可以在不使循环数无效的情况下进行拼接（例如，在循环期间通过更改数组长度）。如果顺序很重要，则按通常的正向循环并复制每个字符串的第一个匹配项到一个新的数组，或像这样修改循环计数器。这可能是我使用的技术，因为它保留秩序，并保持每个字符串的第一个遇到的实例：

import flash.utils.Dictionary; 

var array:Array = ["harry","potter","ron","harry","snape","ginny","ron"]; 
var dict:Dictionary = new Dictionary(); 

var len:int = array.length; 
for (var i:int = 0; i<len; ++i) 
{ 
    var str:String = array[i] as String; 
    if (!dict[str]) 
    { 
     dict[str] = true; 
    } 
    else 
    { 
     array.splice(i,1); 
     i--; len--; 
    } 
} 

dict = null; 


trace(array); 

Answer 3

这是为了做这件事，我敢肯定还有其他的。

function removeDuplicate(sourceArray:Array) : void 
{ 
    for (var i:int = 0; i < sourceArray.length - 1; i++) 
    { 
     for (var j:int = i + 1; j < sourceArray.length; j++) 
     { 
       if (sourceArray[i] === sourceArray[j]) 
       { 
        // Remove duplicated element and decrease j index. 
        sourceArray.splice(j--, 1); 
       } 
     } 
    } 
} 

Answer 4

这里是另一种方式来做到这一点，可能是一个更好一点看：

var removeList:Array = []; 

// loop over every item in the original array 
for each (var item:* in array) { 
    // loop over every item again, checking for duplicates 
    for each (var other:* in array) { 
     // if two items that aren't the same item are equal and `other` doesn't 
     // exist in the remove list, then cache it for later removal. 
     if (item == other && item !== other && removeList.indexOf(other) == -1) 
      removeList.push(other); 
    } 
} 

// next, loop over the cached remove list and remove 'selected' items for removal 
for each (var remove:* in removeList) 
    array.splice(array.indexOf(remove), 1); 

这可能是没有这样做，@原型法的最高效的方式可能更有效，但它是你问:)

Answer 5

如果sourceArray [i]不止一次与sourceArray [j]匹配，那么@prototypical s的响应不会给出问题，因为如果元素已经被.splice（）d超过，sourceArray的长度会更短？

我已经重写这个方法从年底数量，使得这种情况不会发生

for (var i:int = sourceArray.length - 2; i >= 0; --i) 
{ 
    for (var j:int = sourceArray.length - 1; j > i; --j) 
    { 
     trace(i, j); 
     if (sourceArray[j] === sourceArray[i]) sourceArray.splice(j, 1); 
    } 
} 

Answer 6

我投了亚当的选项，但后来我发现这一点，在我看来，这可能是更好的性能明智吗？

for (var i:uint = array.length; i > 0; i--){ 
    if (array.indexOf(array[i-1]) != i-1){ 
     array.splice(i-1,1); 
    } 
    }  

的此想法是，你向后循环通过数组，并自的indexOf给你第一个出现的指数，可以查看与当前指数（I）的发现指数如果不相同删除。

Answer 7

好答案！

我检查了其中的一些，并且与我的对比结果更差。 这很简单：

var originalV : Vector.<String> = Vector.<String>(["a", "c", "d", "c", "b", "a", "e", "b", "a"]); 
var resultV : Vector.<String> = new Vector.<String>(); 

var i : int, len : uint = linkedReferencesArr.length; 
while(i < len) { 
    var el : String = linkedReferencesArr[i]; 
    if(resultV.indexOf(el) == -1) resultV.push(el); 
    i++; 
} 

trace(resultV); // here is vector with unique elements 

欢迎你们！

---

统计与我的数据：

快译通方法：8946ms，8718ms，8936ms

的OBJ方法：8800ms，8809ms，8769ms

我的老办法：8723ms，8599ms，8700ms

此方法：6771ms，6867ms，6706ms