Duplicating objects

[Christopher Benson-Manica]

Is there a general mechanism to duplicate, or provide for the
duplication of, objects? As an example, suppose I need to duplicate
an array. I can accomplish this with array.slice( 0 ), but that's not
going to cut in general. I could also add a copy method to the Array
prototype, like so:

Array.prototype.copy=function() {
var newArray=[];
for( var idx=0; idx < this.length; idx++ ) {
newArray.push( this[idx] );
}
return newArray;
}

and I could write similar copy() methods for various objects. But I
feel certain that I'm not the first programmer who has had a need for
such functionality. What is the canonical way of doing this?

 

[Evertjan.]

Christopher Benson-Manica wrote on 06 dec 2005 in comp.lang.javascript:

Is there a general mechanism to duplicate, or provide for the
duplication of, objects? As an example, suppose I need to duplicate
an array. I can accomplish this with array.slice( 0 ), but that's not
going to cut in general. I could also add a copy method to the Array
prototype, like so:

Array.prototype.copy=function() {
var newArray=[];
for( var idx=0; idx < this.length; idx++ ) {
newArray.push( this[idx] );
}
return newArray;
}

Array.prototype.copy=function() {
return this.concat();
}

or simply us an empty .concat() by itself:


var b = a.concat()

 

[VK]

Is there a general mechanism to duplicate, or provide for the
duplication of, objects? As an example, suppose I need to duplicate
an array. I can accomplish this with array.slice( 0 ), but that's not
going to cut in general. I could also add a copy method to the Array
prototype, like so:

Array.prototype.copy=function() {
var newArray=[];
for( var idx=0; idx < this.length; idx++ ) {
newArray.push( this[idx] );
}
return newArray;
}

and I could write similar copy() methods for various objects. But I
feel certain that I'm not the first programmer who has had a need for
such functionality. What is the canonical way of doing this?

There is not such so feel free to propose one ;-)
JavaScript object doesn't have clone() method.

So in case of array your options are:
1) If array doesn't have other arrays in it (psi-"single-dimention")
you use:
var arrayOneCopy = arrayOne.slice(0);

2) If array does have other arrays in it (psi-"multi-dimention") you
use your code but just make it *recursive* and check for each single
element if it's not an array.

3) Also if you don't mind of JSON then you can

var arrayOneCopy = JSON.parse(JSON.stringify(arrayOne));

 

[Christopher Benson-Manica]

<[email protected]>

There is not such so feel free to propose one ;-)

Surely someone has already done so? I can't imagine I'm the first
person who's wanted duplicated objects...

JavaScript object doesn't have clone() method.

Any particular reason for that?

2) If array does have other arrays in it (psi-"multi-dimention") you
use your code but just make it *recursive* and check for each single
element if it's not an array.

Well, as long as I'm proposing things...

Object.prototype.copy=function( deep ) {
return this; // Use references by default
}

Array.prototype.copy=function( deep ) {
var c=[];
for( var idx=0; idx < this.length; idx++ ) {
if( deep ) {
c.push( this[idx].copy(true) );
}
else {
c.push( this[idx] );
}
}
return c;
}

 

[Christopher Benson-Manica]

Array.prototype.copy=function( deep ) {
var c=[];
for( var idx=0; idx < this.length; idx++ ) {
if( deep ) {
c.push( this[idx].copy(true) );
}
else {
c.push( this[idx] );
}
}
return c;
}

Let me try again:

Array.prototype.copy=function( deep ) {
if( !deep ) {
return this.concat();
}
var c=[];
for( var idx=0; idx < this.length; idx++ ) {
c.push( this[idx].copy(true) );
}
return c;
}

 

[RobG]

Array.prototype.copy=function( deep ) {
var c=[];
for( var idx=0; idx < this.length; idx++ ) {
if( deep ) {
c.push( this[idx].copy(true) );
}
else {
c.push( this[idx] );
}
}
return c;
}

Let me try again:

Array.prototype.copy=function( deep ) {
if( !deep ) {
return this.concat();
}
var c=[];
for( var idx=0; idx < this.length; idx++ ) {
c.push( this[idx].copy(true) );
}
return c;
}

That will only work where all the elements of the array are arrays, and
it fails when it gets to elements that aren't arrays.

Here's my test:

var a = [[1,2,3],1,2,3];
var b = a.copy(true); // 'this[idx].copy is not a function'
a[0][1] *=5;
alert(a[0] + '\n' + b[0]);

Here's a copy method based on something I wrote some time ago to copy
multi-dimensional arrays:

Array.prototype.copy=function() {
var A = this;
var B = [];
for (var i=0, j=A.length; i<j; ++i){
if (typeof A == 'object' && Array == A.constructor ){
B = arrayCopy(A);
} else {
B = A;
}
}
return B;
}

It is very much slower than concat(), but for small arrays it may be OK.

It will also only work on arrays of primitives, it will not work if an
element is an object other than an array. You could extend it to handle
other types of objects, but that's pretty much what JSON.parse does, so
VK's JSON.parse suggestion may be better.

<URL:http://www.crockford.com/JSON/js.html>

 

[Richard Cornford]

Is there a general mechanism to duplicate, or provide
for the duplication of, objects?
No.

As an example, suppose I need to duplicate
an array. I can accomplish this with array.slice( 0 ),
but that's not going to cut in general. ...

and I could write similar copy() methods for various
objects. But I feel certain that I'm not the first
programmer who has had a need for such functionality.

You are not but the reason for copying an object has a big influence
upon how you would go about it. For example, prototype-based clones can
be useful:-

var protoCloneObject = (function(){
function constr(){
;
}
return (function(obj){
constr.prototype = obj;
return new constr();
});
})();

- so that you can create an object as:-

var firstObj = new SomeObject(x, y, z);

- and then create a new object that has all of the properties and
methods of the first object with:-

var clone = protoCloneObject(firstObj);

- but is still a distinct object instance. With the significant proviso
that acting upon the copy will modify the copy but acting upon the first
object will also modify all of its copies until those copies have been
modified in a way that masks the changes in their prototype.

So in some circumstances the result is exactly what you need, and in
others it is extremely dubious.

What is the canonical way of doing this?

There isn't, and there probably should not be one.

Richard.

 

[Christopher Benson-Manica]

That will only work where all the elements of the array are arrays, and
it fails when it gets to elements that aren't arrays.

Well, in my previous post, I had

Object.prototype.copy=function() {
return this;
}

which should make it conceptually a no-op except for classes which
overrride copy.

It will also only work on arrays of primitives, it will not work if an
element is an object other than an array. You could extend it to handle
other types of objects, but that's pretty much what JSON.parse does, so
VK's JSON.parse suggestion may be better.

I will take a look at that in the morning; thanks.

 

[884443zf]

sure!

 

[Thomas 'PointedEars' Lahn]

Well, in my previous post, I had

Object.prototype.copy=function() {
return this;
}

which should make it conceptually a no-op except for classes which
overrride copy.

Again: there are _no_ classes in the languages usually discussed
here (ECMAScript implementations in a client-side environment);
those are OO languages using prototype-based inheritance.

Your method returns a reference to the calling object; that is not
copying an object, it is retrieving a reference to that object.
Given your prototype method above:

var x = {foo: 'bar'}; // x.foo == 'bar'
var y = x.copy(); // y.foo == 'bar'
y.foo = 42; // y.foo == 42
alert(x.foo); // 42 (not 'bar')

Graphically, that is:

1. object1
2. x --------> object1
3. x --------> object1 <-------- y

What you wanted is:

1. object1
1. x --------> object1
2. object2
3. Copy all properties and property values from object1 to object2.
4. object2 <-------- y


PointedEars

 

[Jambalaya]

3) Also if you don't mind of JSON then you can
var arrayOneCopy = JSON.parse(JSON.stringify(arrayOne));

And since security is not a concern as this data already exists in a
local variable, this would be faster.
var arrayOneCopy = eval(JSON.stringify(arrayOne));

Probably one of the only times I would feel comfortable with eval.

 

[Christopher Benson-Manica]

Your method returns a reference to the calling object; that is not
copying an object, it is retrieving a reference to that object.

That's intentional. If an object's prototype doesn't override the
inherited copy(), it doesn't copy itself. That seems like reasonable
default behavior to me.

 

[Thomas 'PointedEars' Lahn]

That's intentional. If an object's prototype doesn't override the
inherited copy(), it doesn't copy itself. That seems like reasonable
default behavior to me.

It does not seem to me, given that Object objects are
extensible, too, without inheriting from another prototype.

My example shows that your approach fails badly on those,
and an approach that fails even with the simplest of objects
can hardly be considered viable for a general solution.


PointedEars

 

[Christopher Benson-Manica]

It does not seem to me, given that Object objects are
extensible, too, without inheriting from another prototype.

I'm not sure I get you here.

and an approach that fails even with the simplest of objects
can hardly be considered viable for a general solution.

Yes, I haven't provided a way for any generic object to be copied.
For my purposes, however, the ability to specify whether objects of
prototype X are copied by reference or value is good enough for a
number of purposes, not least of which is solving the minor problem
that motivated this line of questioning in the first place.

 

[Thomas 'PointedEars' Lahn]

I'm not sure I get you here.

var x = {foo: 'bar'};

is defining the reference `x' to a newly created Object object,
that is extended by adding a new property, `foo'. It is the same
as

var x = new Object();
x.foo = 'bar';

That object is extensible and extended here without the use of another
prototype (object). And since all non-host objects are extensible ...

Yes, I haven't provided a way for any generic object to be copied.
For my purposes, however, the ability to specify whether objects of
prototype X are copied by reference or value is good enough for a

"copied by reference or value"? Object references and primitive values
are the only property values you can copy this way. References _are_
values in JS.

number of purposes, not least of which is solving the minor problem
that motivated this line of questioning in the first place.

Fair enough, but you need to be aware, and I am not sure that you already
are, that, consequently, copying properties which values are references to
Object objects (or any user-defined object that does not have a constructor
with a prototype object that defines anything different for that matter),
will not result in copying those objects. It will merely result in copying
the reference to that object, hence modifying the property of such
properties of original object1 will result in modifying the property of
such properties of its "copy" object2:

var object1 = {foo: {bar: 42}};
var object2 = object1.copy();
object2.foo.bar = 23;
alert(object1.foo.bar); // 23, not 42

1. original object
2. object1 --------> original object
3. object1.foo ----> {bar: 42}
4. Create "copy" of object1.
5. _Copy_ property _values_ from object1 to object2.
6. "copy" <-------- object2
7. object1.foo ----> {bar: 42} <------- object2.foo

That goes of course for all objects where only shallow copying of property
values is performed.


PointedEars

 

[Christopher Benson-Manica]

"copied by reference or value"? Object references and primitive values
are the only property values you can copy this way. References _are_
values in JS.

All right, I'll put it another way - the ability to choose whether the
reference I get is to the original object or a new object with the
same properties.

Fair enough, but you need to be aware, and I am not sure that you already
are, that, consequently, copying properties which values are references to
Object objects (or any user-defined object that does not have a constructor
with a prototype object that defines anything different for that matter),
will not result in copying those objects.

Yes, I am aware of that fact, and that is actually the precise
behavior I'm looking for. I do appreciate the heads up all same,
however.