В AS3, проще говоря, есть два типа данных: примитивные ( int , uint , Число , Boolean , String ) и объекты (все остальное, даже базовые Object и Array типы).Примитивные данные копируются по их значениям:
var a:int = 1;
var b:int;
// Now we pass the value of a.
b = a;
a = 2;
trace(a); // output: 2
trace(b); // output: 1
Затем все объекты передаются по их ссылке (как указатели на языке C / C ++), поэтому существует только один оригинальный экземпляр объекта и несколько ссылок наit:
var A:Array = [1, 2];
var B:Array;
// Now we pass the reference to the A.
B = A;
A[0] = 2;
trace(A); // output: 2,2
trace(B); // output: 2,2
Чтобы скопировать данные объекта, вам нужно немного понять.Существуют DodgerThud условия, глубокая копия и мелкая копия условия.Просто, shallow copy создает клон контейнера верхнего уровня, копируя более глубокие уровни как есть.Копия глубокая клонирует все на дно, поэтому одна из копий не будет затронута каким-либо образом, независимо от того, что вы делаете с другой.
Для поверхностной копии Array :
var A:Array = [1,2,[3]];
var B:Array;
// Make a shallow copy.
B = A.slice();
// Lets change the original and see.
A[0] = 2;
A[1] = 3;
A[2][0] = 4;
trace(A); // output: 2,3,4
trace(B); // output: 1,2,4
Итак, A и B различны Array s, но их последний элемент относится к тому же Array .
Toмелкая копия объекта:
var A:Object = {a:1,b:2,c:[3]};
var B:Object;
// Make a shallow copy.
B = new Object;
// Iterate over keys in A.
for (var aKey:String in A)
{
// Copy members of A one by one.
B[aKey] = A[aKey];
}
// Let's change the original and see.
A.a = 2;
A.b = 3;
A.c[0] = 4;
trace(A.a, A.b, A.c); // output: 2 3 4
trace(B.a, B.b, B.c); // output: 1 2 4
Затем глубокая копия.Обычно вы рекурсивно перебираете объект верхнего уровня и всех его потомков, чтобы убедиться, что каждый фрагмент данных идет как копия, а не как ссылка на исходные данные.В то же время вы наблюдаете за повторяющимися записями и циклическими ссылками.
Однако (и к счастью) в AS3 есть несколько ярлыков для этого.Вы можете глубоко копировать через ByteArray .Это будет (проверено и подтверждено) обработать дубликаты и циклические ссылки очень хорошо:
function deepCopy(source:*):*
{
var BA:ByteArray = new ByteArray;
BA.writeObject(source);
BA.position = 0;
var result:* = BA.readObject();
BA.clear();
return result;
}
var A:Array = [1, 2, [3]];
var B:Array = deepCopy(A);
// Let's change the original and see.
A[0] = 2;
A[1] = 3;
A[2][0] = 4;
trace(A); // output: 2,3,4
trace(B); // output: 1,2,3
Не уверен, будет ли это как-то быстрее, или лучше, или более оптимальным, но все же, другим способом:
function deepCopy(source:*):*
{
return JSON.parse(JSON.stringify(source));
}
Существует несколько идей о них обоих.
JSON глубокая копия:
- дубликаты: нет (клонирует их какотдельные объекты)
- циклические ссылки: нет (ошибка времени выполнения)
- пользовательские классы: нет
- поддерживаемые типы данных: int, uint, Number, Boolean, String, Object, Array
ByteArray глубокая копия:
- дубликаты: да
- циклические ссылки: да
- пользовательские классы:via registerClassAlias method
- поддерживаемые типы данных: int, uint, Number, Boolean, String, Object, Array, ByteArray
Вот моя собственная версия deepCopy :
private const SIMPLE:Object =
{
"number":true,
"string":true,
"boolean":true,
"undefined":true
};
private const XNODE:String = getQualifiedClassName(XML);
private const XLIST:String = getQualifiedClassName(XMLList);
private const ARRAY:String = getQualifiedClassName(Array);
private const OBJECT:String = getQualifiedClassName(Object);
private const BYTES:String = getQualifiedClassName(ByteArray);
private var lock:Dictionary;
private function deepCopy(source:*):*
{
// Handle primitive data.
if (source == null) return source;
if (source is Class) return source;
if (SIMPLE[typeof(source)]) return source;
var result:*;
var aLock:Boolean;
var aQname:String;
if (!lock)
{
// If we're here, then we're at the top level
// so we should devise cache for handling
// duplicates and circular references.
lock = new Dictionary;
aLock = true;
}
// If it is cached, then it is either
// duplicate or circular reference.
if (lock[source]) return lock[source];
aQname = getQualifiedClassName(source);
if (aQname == BYTES)
{
var aBytes:ByteArray;
aBytes = new ByteArray;
aBytes.writeBytes(source, 0, source.length);
result = aBytes;
lock[source] = result;
}
else if (aQname == ARRAY)
{
var aRay:Array;
aRay = new Array;
aRay.length = source.length;
result = aRay;
lock[source] = result;
// Copy the elements of the source Array one by one.
for (var i:int = 0; i < aRay.length; i++)
{
aRay[i] = deepCopy(source[i]);
}
}
else if (aQname == OBJECT)
{
var aRes:Object;
aRes = new Object;
result = aRes;
lock[source] = result;
// Copy the members of the source Object one by one.
for (var aKey:String in source)
{
aRes[aKey] = deepCopy(source[aKey]);
}
}
else if ((aQname == XNODE) || (aQname == XLIST))
{
// This one is tricky. The object to clone might
// have a reference to some descendant node of some
// big XML. There could be several references to
// different sub-nodes either. Probably you should
// not rely on this method to clone XML data unless
// you are totally aware of what you are doing.
result = source.copy();
lock[source] = result;
}
else
{
// If we're here, that means that source holds
// a reference to some class instance. You should
// define here your own ways to handle them.
result = source;
}
if (aLock)
{
// If we're here, then we're at the top level
// so we should do some clean-up before we leave.
for (var aRef:* in lock)
{
delete lock[aRef];
}
lock = null;
}
return result;
}
Пользовательская глубокая копия:
- дубликаты: да
- циклические ссылки: yes
- пользовательские классы: вы должны определить свои собственные правила обработки их
- поддерживаемые типы данных: int, uint, Number, Boolean, String, Object, Array, ByteArray, XML (limited), конструкторы классов