ActionScript - 比较和删除复杂数组的重复项?
比较时简单数组,我使用类似下面的函数来连接并删除重复:ActionScript - 比较和删除复杂数组的重复项?
//Merge
public function merge(a1:Array, a2:Array):Array
{
var result:Array = a1.concat(a2);
var dictionary:Dictionary = new Dictionary();
for each (var item:Object in result)
dictionary[item] = true;
result = new Array();
for (var key:Object in dictionary)
result.push(key);
dictionary = null;
return result;
}
然而,这种方法并不复杂的数组。
是否有一个众所周知的算法,或者甚至有可能写一个递归函数来比较Vector.<Object>
与另一个?即使被比较的某些对象有额外的键/值对,它也会始终工作?
[编辑]
更加明确,使用字典,以确定是否在一个简单的数组项仅适用于基本数据类型(int,数字,字符串等。 )或对象引用,所以如果它是通过2个阵列类似于像这样上面的例子中的工作原理:
var arr1:Array = new Array(1, 2, 3, 4, 5);
var arr2:Array = new Array(8, 7, 6, 5, 4);
导致合并数组与跟随着g值:
1, 2, 3, 8, 7, 6, 5, 4
相反
,即时询问是否有可能传递函数2个复杂阵列或Vector.<Object>
可以具有相同的键/值对和所得Vector.<Object>
除去redundencies所有包含唯一对象。例如:
var vec1:Vector.<Object> = new Vector.<Object>();
vec1.push({city:"Montreal", country:"Canada"});
vec1.push({city:"Halifax", country:"Canada"});
var vec2:Vector.<Object> = new Vector.<Object>();
vec2.push({city:"Halifax", country:"Canada"});
vec2.push({city:"Toronto", country:"Canada"});
合并上述2名矢量对象会导致以下矢量通过确定和移除具有相同的键/值对的对象:
{city:"Montreal", country:"Canada"}
{city:"Halifax", country:"Canada"}
{city:"Toronto", country:"Canada"}
我搜索的算法可能处理这些类似对象的移除,而不必知道它们的特定键/值名称或对象内有多少个键/值对。
当然,你可以,你可以建立与任何类型为向量的类似的例子:
public function mergeObjectVectors(v1:Vector.<Object>,
v2:Vector.<Object>):Vector.<Object>
{
var dictionary:Dictionary = new Dictionary();
var concat:Vector.<Object> = v1.concat(v2);
var result:Vector.<Object> = new Vector.<Object>();
for each(var i:Object in concat)
{
if (!dictionary[i])
{
dictionary[i] = true;
result.push(i);
}
}
return result;
}
但是,如果你计划在任何类型的接受的载体,它的不同:
public function testing():void
{
var v1:Vector.<Object> = new Vector.<Object>();
v1.push({name:"Object 1"});
v1.push({name:"Object 2"});
// Vector w duplicates
var v2:Vector.<Object> = new Vector.<Object>();
var o:Object = {name:"Object 3"};
v2.push(o);
v2.push(o);
v2.push(o);
var resultVector:Vector.<Object> = mergeAnything(v1, v2, Class(Vector.<Object>));
var resultArray:Array = mergeAnything(v1, v2, Array);
var resultObject:Object = mergeAnything(v1, v2, Object);
}
public function mergeAnything(o1:Object, o2:Object, resultClass:Class):*
{
var dictionary:Dictionary = new Dictionary();
var result:Object = new resultClass();
var i:int;
for each(var o:Object in o1)
{
if (!dictionary[o])
{
dictionary[o] = true;
result[i++] = o;
}
}
for each(o in o2)
{
if (!dictionary[o])
{
dictionary[o] = true;
result[i++] = o;
}
}
return result;
}
第一示例将更加节省资源。
编辑: 这应该这样做,试试你的榜样:
public function mergeObjectVectors(v1:Vector.<Object>, v2:Vector.<Object>):Vector.<Object>
{
var concat:Vector.<Object> = v1.concat(v2);
var result:Vector.<Object> = new Vector.<Object>();
var n:int = concat.length;
loop:for (var i:int = 0; i < n; i++)
{
var objectToAdd:Object = concat[i];
var m:int = result.length;
for (var j:int = 0; j < m; j++)
{
var addedObject:Object = result[j];
if (this.areObjectsIdentical(objectToAdd, addedObject))
{
continue loop;
}
}
result.push(objectToAdd);
}
return result;
}
private function areObjectsIdentical(o1:Object, o2:Object):Boolean
{
var numComparisons:int = 0;
for (var s:String in o1)
{
numComparisons++;
if (o1[s] != o2[s])
{
return false;
}
}
for (s in o2)
{
numComparisons--;
}
return !numComparisons;
}
好像你可以将一个数组作为一个向量,所以你所要做的就是返回一个数组并将其作为一个向量。 – recursivity
很像我以前的尝试,我也不能让你的第一个例子工作。我传递了函数2矢量,它们都包含具有相同的键/值对的这个对象:'{city:“蒙特利尔,年龄:369},但两者仍然被添加到结果矢量中。 – TheDarkIn1978
即使它们包含相同的信息,它们也会是不同的对象(实例化了两次),因此生成的向量将包含这两个对象,但这也应该发生在数组中。 – recursivity
嗨,你换成'dataProperty'的例子'result'。 – recursivity
啊,错过了。固定。 – TheDarkIn1978