Batch assignment functions

Rick Waldron waldron.rick at
Wed Aug 15 12:42:11 PDT 2012

 Recently, Allen produced a strawman proposal[0][1] for the "object define
properties" operator, which was designed to provide syntax that
differentiated semantics of define vs. assign. Towards the end of the
thread, IIRC, Brendan suggested some new Object functions: Object.define()
and Object.assign().[2]

I spent time over the weekend preparing common use cases for batch
assignment based on real world examples from jQuery[3], Dojo[4], Node.js[5]
and Lodash (an improved Underscore)[6][7] (With all due respect, Prototype
is no longer considered a relevant library for use in modern day web
development). Initially, I assumed that the jQuery "deep extend" was the
common case and drafted an attempt at handling "nested assignment" or "deep
extending". Off-list, Dave Herman reminded me that there is no way to know
what the user _actually_ wants with regard to nested object properties:

1. Target property does not exist: define source value
2. Target property exists, its value is anything _except_ a nested object:
Assign source value
3. Target property exists, its value is a nested object, the source
property value is anything _except_ a nested object: Assign source value

The ambiguity:

4. Target property exists, its value is a nested object, the source
property is a nested object: _____?

In the trenches we use an icky boolean trap[8] flag to tell the jQuery API
what we want; jQuery.extend( true, a, b ) will assume you want to "deep
merge/extend" b into a and will do so by using a pure evil function called
jQuery.isPlainObject to determine if an object was created from Object or
{}. Regardless, this is not an arguable use case, it's a reality.

As a result, I re-drafted Object.assign based on the real-world use cases,
but specifically does not attempt nested object property assignment
recursion. At this point I still believe that the deep nested assignement
case is strong enough to consider, but I'm not sure how to approach it. It
might warrant its own implicit "merge object properties whenever
possible"... Object.merge?

In summary, based on findings so far, I'd like to propose the following:

In all cases, "target" refers to an object in the "dictionary of values" or
"bag of properties" sense. "source" can be any kind of object that has own

Object.define( target, source ): defineProperties w/ sensible defaults (w,
e, c: true).

Object.put( target, source ): is... "put"! (

Object.merge( target, source ): "deep put", ideally this would drill down
into nested objects that "line up" on the left and right, [[Put]]ing values
from the right onto the left. I want to make it perfecty clear that this is
desired, but the semantics are not yet clear.







I included this, but primarily, users will require underscore or
lodash for such utilities)



-------------- next part --------------
An HTML attachment was scrubbed...
URL: <>

More information about the es-discuss mailing list