Operator overloading for non-value objects

Andrea Giammarchi andrea.giammarchi at gmail.com
Tue Jan 14 10:07:45 PST 2014


for correctness sake, I forgot to check `this.every()` after a `this.length
=== collection.length && this.every(...)`


On Tue, Jan 14, 2014 at 9:58 AM, Andrea Giammarchi <
andrea.giammarchi at gmail.com> wrote:

> I think there are cases where the intent of `==` can be clear such Point2D
> or Point3D comparison, as well as generic collections.
>
> In this case I am simulating though `hasSamecontentOf` method what I think
> would be nice simplifying via `==`
>
> ```javascript
>
> function Collection(entries) {
>   this.push.apply(this, entries);
> }
>
> Collection.prototype = Object.setPrototypeOf(
>   {
>     constructor: Collection,
>     hasSameContentOf: function (collection) {
>       return this.every(this._sameContentOf, collection);
>     },
>     _sameContentOf: function (entry, i) {
>       return entry === this[i];
>       // or a more generic and unoptimized
>       // return -1 < this.indexOf(entry);
>     }
>   },
>   Array.prototype
> );
>
> var
>   a = new Collection([1, 2, 3]),
>   b = new Collection([1, 2, 3]),
>   c = new Collection(a)
> ;
>
> alert(
>   a.hasSameContentOf(b) &&
>   b.hasSameContentOf(c)
> );
>
> ```
>
> In JS world we are "use to" compare via === so that when == is used
> instead we are usually in "power user land", I don't see any conceptual
> shenanigans in doing something like above code.
>
> Long story short:
>
> `point2Da.x === point2Db.x && point2Da.y === point2Db.y`
>
> all over the code, if somehow necessary, would probably not look as nice
> as `pointa == pointb`
>
>
> Being something new not possible in ES5 or ES3, I don't even see side
> effects or regressions that could affect old code: no oervload of `==`
> would be present so we are back to the good old known `==` meaning.
>
>
> my 2 cents
>
>
>
> On Tue, Jan 14, 2014 at 9:06 AM, Kevin Smith <zenparsing at gmail.com> wrote:
>
>>
>>> In the worst case, when I don't know if I have a string or an URLUtils
>>> object, I just ensure that at least one member of the equality operator is
>>> stringified—and, most importantly, that it is evident from reading my code
>>> that one member is stringified:
>>>
>>>     a.href == url
>>>     String(whatever) == url
>>>
>>
>> Is an equality operator which requires one to remember such details a
>> good, dependable equality operator?  Does it really even express a
>> meaningful concept of "equality"?
>>
>> Attaching more nuance on top of "==" via overloading seems like it will
>> make things worse, not better.
>>
>> Brendan, can you provide a value class example which includes a
>> user-defined "=="?  I'd like to see it in context.
>>
>>
>>
>> _______________________________________________
>> es-discuss mailing list
>> es-discuss at mozilla.org
>> https://mail.mozilla.org/listinfo/es-discuss
>>
>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20140114/1a9d04e4/attachment-0001.html>


More information about the es-discuss mailing list