kristopolous kristopolous - 1 month ago 4
Javascript Question

Native way to merge objects in Javascript

Javascript's Object doesn't have any native merge operation. If you have two objects, say

{a:1, b:2}
{c:3, d:4}


And want to get

{a:1, b:2, c:3, d:4}


As far as I know, you have to iterate through the objects. That is to say that you decide on either a merge left or merge right strategy and then you do something like (simplified)

for (key in object2) {
object1[key] = object2[key];
}


This is fine. However, Javascript has the
call
and
prototype
feature. For instance, turning
arguments
into an
Array
can be done with

Array.prototype.slice.call(arguments)


This approach exploits existing native code, and so therefore is less susceptible to programmer folly and should run faster than a non-native implementation.

The question



Is there a trick to use this prototype/call pattern on perhaps the
Attribute
or
Node
traversal features of the DOM, or perhaps some of the generic
String
functions in order to do a native object merge?

The code would look something like this:

var merged = somethingrandom.obscuremethod.call(object1, object2)


And as a result, you'd get a native merge without a traversal.

A possible, sub-optimal solution



If you could use the
constructor
property of an
Object
and then coerce one object to have a constructor of another object and then run
new
over the composite object, you may get a merge for free. But I don't have a firm grasp of the full implications of the
constructor
feature in javascript to make this call.

Lemma



The same question holds true for
Arrays
. A common problem is to take, say 7 arrays of numbers, then try to find out the intersection of those arrays. That is to say, which numbers exist in all 7 arrays.

You could concat them together, then do a sort, and then do a traversal, surely. But it would be nice if there is a generic intersect tucked away somewhere that we can coerce an array to doing natively.

Any thoughts?

edit:

Getting half way there



For the array problem, you could do the following:

array.concat(a, b, c).sort().join(':') and then use some tricky
RegExp
capture and repeat patterns in order to traverse. RegExp implementations, if you don't know, run on a very simple stack-based virtual machine. When you initialize your regular expression that's really a program that gets compiled (RegExp.compile is a deprecated JS method). Then the native runs over the string in a blisteringly fast way. Perhaps you could exploit that for membership thresholds and get better performance...

It still doesn't go all the way though.

Answer

My answer to this will be disappointing, but still:

no

The reason for this is simple: Mr Resig's implementation of merge (or "extend" as it's called for objects) in jQuery is doing a loop, just like the one in your question. You can look at it here. And I dare say that if John Resig hasn't found a clever build-in way to do it, then the mere mortals of stackoverflow won't either :)

Comments