``this = { ...this, par1, par2, par3 }``` Oh, wait, I'm going to point out the problem with what I wrote before anyone else does: this will lose any non-enumerable properties on `this`, which in a class instance is kind of a big no-no. `Object.assign` is better here.
On Sat, 1 Dec 2018 at 20:08 Michael Luder-Rosefield <rosyatran...@gmail.com> wrote: > > ```js > this.{} = {par1, par2, par3}; > ``` > > Of course, that could be expressed as ```this = { ...this, par1, par2, > par3 }```, but that's still a bit verbose. > > I already know this is going to get dismissed for changing the way the `+` > operator works, but it strikes me that a better way of expressing that > might be ```this += { par1, par2, par3 }```. > > That naturally leads to having ```obj1 + obj2 === Object.assign(obj1, > obj2)``` and ```arr1 + arr2 === (arr1 = [ ...arr1, ...arr2 ])```, which > would be good except for the whole breaking-change thing. > > On Fri, 30 Nov 2018 at 22:52 Simo Costa <andrysimo1...@gmail.com> wrote: > >> Thank you T.J. Crowder for giving me your opinion on this proposal. >> I didn't know about the Bob Myers' for pick notation and it isn't bad. >> >> I still prefer something like that: >> ```js >> constructor(this.{par1, par2, par3}) { >> } >> ``` >> >> but this doesn't sound bad to me: >> >> ```js >> constructor(par1, par2, par3) { >> this.{} = {par1, par2, par3}; >> } >> ``` >> >> There is still a repetition, but it is a a step forward. >> >> Il giorno gio 29 nov 2018 alle ore 12:28 T.J. Crowder < >> tj.crow...@farsightsoftware.com> ha scritto: >> >>> On Wed, Nov 28, 2018 at 6:33 PM Simo Costa >>> <andrysimo1...@gmail.com> wrote: >>> > >>> > So my proposal is to avoid those repetitions... >>> >>> I'm a bit surprised to find that no one's mentioned Bob Myers' >>> [proposal][1] for pick notation yet, which would readily address this >>> requirement *and* various other requirements beyond initializing >>> newly-constructed objects. >>> >>> Using Bob's current draft syntax, Simo's example would be: >>> >>> ```js >>> constructor(par1, par2, par3) { >>> this.{par1, par2, par3} = {par1, par2, par3}; >>> } >>> ``` >>> >>> or if the constructor accepts an object: >>> >>> ```js >>> constructor(options) { >>> this.{par1, par2, par3} = options; >>> } >>> ``` >>> >>> But I think we can go further if we tweak the syntax a bit. Perhaps: >>> >>> ```js >>> constructor(par1, par2, par3) { >>> this.{} = {par1, par2, par3}; >>> } >>> ``` >>> >>> ...where the property names are inferred from the properties on the >>> right-hand side. That would be functionally equivalent to: >>> >>> ```js >>> constructor(par1, par2, par3) { >>> Object.assign(this, {par1, par2, par3}); >>> } >>> ``` >>> >>> ...but since the syntax is clear about the intent, when an object >>> initializer (rather than just object reference) is used on the right-hand >>> side it's an optimization target if a constructor is "hot" enough to >>> justify it (e.g., an engine could optimize it into individual assignments). >>> >>> For me, that would be a great, clear, concise feature, and hits the >>> other use cases Bob mentions in his proposal. I like that I'm still in >>> control of what parameters get assigned as properties (which I think has >>> been true of all of the suggestsions in this thread). >>> >>> -- T.J. Crowder >>> >>> [1]: https://github.com/rtm/js-pick-notation >>> >> _______________________________________________ >> es-discuss mailing list >> es-discuss@mozilla.org >> https://mail.mozilla.org/listinfo/es-discuss >> >
_______________________________________________ es-discuss mailing list es-discuss@mozilla.org https://mail.mozilla.org/listinfo/es-discuss