comportamento assurdo

[Walessio]

Mi sono sbattuto la testa per un po' su un applicazione che ha degli array e poi sono incappato in un comportamento di AS3 che ritengo assolutamente assurdo e ingiustificabile.
Ho poi scoperto facendo un test che javascript si comporta nella stessa maniera, poi ho provato con PHP e lì tutto a posto.
Qual'è questa anomalia?
Assegnando un array uguale a un altro array, l'interprete li tratta come se fossero la stessa variabile, al punto che modificando il primo si modifica anche il secondo e viceversa!

Ecco il codice ActionScript:

var A1:Array = new Array();
trace("var A1:Array = new Array();");
A1.push("1");
A1.push("2");
A1.push("3");
trace("A1:"+A1);

var A2:Array = new Array();
A2 = A1;
var A3:Array = new Array();
A3 = A1;
trace("\nA2 = A1\nA3 = A1");
trace("A1:"+A1);
trace("A1:"+A2);
trace("\nA2 = A2.reverse();\n");
A2 = A2.reverse();
trace("A1:"+A1);
trace("A2:"+A2);
var A4:Array = new Array();

for(var i=0;i<A1.length;i++){
A4[i]=A1[i];
}

trace("var A4:Array = new Array();\n"+ "for(var i=0;i<A1.length;i++){\n"+ "A4[i]=A1[i];\n"+ "}"); trace("A4:"+A4);
A3.pop();

trace("\nA3.pop();\n");
trace("A1:"+A1);
trace("A2:"+A2);
trace("A3:"+A3);
trace("A4:"+A4);

Ed ecco il risultato dei trace:

var A1:Array = new Array();
A1:1,2,3
A2 = A1
A3 = A1
A1:1,2,3
A1:1,2,3
A2 = A2.reverse();
A1:3,2,1
A2:3,2,1
var A4:Array = new Array();

for(var i=0;i<A1.length;i++){
A4[i]=A1[i];
}

A4:3,2,1
A3.pop();
A1:3,2
A2:3,2
A3:3,2
A4:3,2,1

Come potete vedere, gli array A2 e A3 sono stati assegnati uguali all'A1 con le istruzioni A2 = A1 e A3 = A1, mentre in A4 i valori di A1 sono stati copiati con un ciclo.

eseguendo i metodi reverse e pop su A1,A2 e A3, le modifiche che essi comportando si propagano tra questi tre array come se fossero la stessa istanza di oggetto.

A4 invece resta indipendente.

Javascript si comporta nello stesso modo.
In PHP questo comportamento non si verifica ma non si verifica nemmeno in AS3 con l'oggetto Number, infatti se provate a fare questo test:

var N1:Number = new Number();
N1 = 10;
var N2:Number = new Number();
N2 = N1;
trace("N1:"+N1);
trace("N2:"+N2);
N2++; trace("N2++");
trace("N2:"+N2);
trace("N1:"+N1);
trace("N2:"+N2);

Infine ho provato con un Object e il comportamento degli array si è replicato, modificando uno degli oggetti, l'altro viene modificato di conseguenza come se fossero lo stesso oggetto.

var o1:Object = new Object();
o1.a = "a";
o1.b = "b";
o1.c = "c";
var o2:Object = new Object();
o2 = new Object();
o1.a = "aa";
trace("o1"+o1.a+","+o1.b+","+o1.c);
trace("o2"+o2.a+","+o2.b+","+o2.c);

L'unica spiegazione che trovo è che gli oggetti complessi (come Array e Object) vengano assegnati per riferimento.
Vabbè... ma allora come faccio ad avere due oggetti uguali (ovvero che hanno gli stessi identici contenuti) ma indipendenti tra loro?
Se dichiaro due oggetti uguali io non voglio che modificando uno si modifichi l'altro!