Object.equals() and Object.clone()
It's pretty hard to decide how these behave, specifically with custom classes. Focusing on Object.clone...
- with classes do you call the constructor, and with what arguments?
- HTMLElement and sub classes can't be constructed directly, what happens with them?
- do you copy internal properties? this would make it hard to polyfill
- how does it behave with getters and setters?
- with regular expressions do you copy the lastIndex?
Most of those apply to Object.equals also.
I agree. Also, consider iterables. Should their Symbol.iterator method be
called? There's no obvious behavior for the details, and people's opinions
differ on what should be correct.
How about beginning with the HTML structured clone algorithm, and a
Symbol.clone property to allow an object to optionally define it's own
cloning behavior?
I think you'd definitely need to call the constructor for classes because of scoped variables (e.g. scoped weakmap for private properties).
I would like a way to compare simple objects like identical arrays though.
I guess it could throw if it's unable to clone something. This would
include any class without Symbol.clone. The error messages would need
to be outstanding for it to be practical. Like showing the path to the
thing that can't be cloned and the name of the constructor.
I didn't know about structured clone so I looked it up. It looks pretty
promising. As for checking if two things are equal, maybe it makes sense
for objects to define their own .equals(other) methods.
developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm
The biggest problem with structured clone is that there’s no way to just invoke it directly. Doing so has been proposed a few times, most recently at whatwg/html#793, but no implementers have expressed interest.
Object has this unfortunate complication of prototypes, i.e.:
const objA = {foo: 1, bar: 2};
const objB = Object.create(objA);
equals(objA, objB) === ?
And also there is metadata on each property that can vary (one object has a property which is configurable, and the other has the same property which is not configurable), and raise similar questions.
Neither of these questions exist on ES's Map type, or Immutable.js's Map and List types, for example.
IMO we should be looking at ways to make those types more suitable for many of the use cases of Object.
It would be nice if deep equality checking and deep cloning of objects was included in the standard library. Has there been any proposals around including these in the past?