Simo Costa (2018-11-28T18:32:53.000Z)
andrysimo1997 at gmail.com (2018-11-29T09:06:21.308Z)
In costructor functions and in the constructor() method in ES6 classes is easily to fall in the following pattern: ``` F(par1, par2, ..., parN) { this.par1 = par1; this.par2 = par2; ... this.parN = parN; } ``` So my proposal is to avoid those repetitions by prefixing a dot `.` to each parameter: ```js F(.par1, .par2, ..., .parN) {} ``` Simple but quite useful. More info here: https://github.com/jfet97/proposal-fast-this-objects-assignments/ \ \ \ [EDIT] It could be a shortcut for: ```js F(this.par1, this.par2, ..., this.parN) {} ``` so we could create and initialize objects in a more general situation: ```js f(obj.par1, obj.par2, obj2.parN) {} ``` equivalent to: ```js f(par1, par2, parN) { let or const obj = { par1, par2 }; let or const obj2 = { parN }; } ``` \ \ [EDIT 2] We can go a step further. When more than one parameters has to be inserted into an object: ```js f(obj.par1, obj.par2, obj.parN) {} ``` we could write: ```js f(obj.{par1, par2, parN}) {} ```
andrysimo1997 at gmail.com (2018-11-29T09:05:53.348Z)
In costructor functions and in the constructor() method in ES6 classes is easily to fall in the following pattern: ``` F(par1, par2, ..., parN) { this.par1 = par1; this.par2 = par2; ... this.parN = parN; } ``` So my proposal is to avoid those repetitions by prefixing a dot `.` to each parameter: ```js F(.par1, .par2, ..., .parN) {} ``` Simple but quite useful. More info here: https://github.com/jfet97/proposal-fast-this-objects-assignments/ \ \ [EDIT] It could be a shortcut for: ```js F(this.par1, this.par2, ..., this.parN) {} ``` so we could create and initialize objects in a more general situation: ```js f(obj.par1, obj.par2, obj2.parN) {} ``` equivalent to: ```js f(par1, par2, parN) { let or const obj = { par1, par2 }; let or const obj2 = { parN }; } ``` \ \ [EDIT 2] We can go a step further. When more than one parameters has to be inserted into an object: ```js f(obj.par1, obj.par2, obj.parN) {} ``` we could write: ```js f(obj.{par1, par2, parN}) {} ```
andrysimo1997 at gmail.com (2018-11-29T09:05:27.133Z)
In costructor functions and in the constructor() method in ES6 classes is easily to fall in the following pattern: ``` F(par1, par2, ..., parN) { this.par1 = par1; this.par2 = par2; ... this.parN = parN; } ``` So my proposal is to avoid those repetitions by prefixing a dot `.` to each parameter: ```js F(.par1, .par2, ..., .parN) {} ``` Simple but quite useful. More info here: https://github.com/jfet97/proposal-fast-this-objects-assignments/ \ \ [EDIT] It could be a shortcut for: ```js F(this.par1, this.par2, ..., this.parN) {} ``` so we could create and initialize objects in a more general situation: ```js f(obj.par1, obj.par2, obj2.parN) {} ``` equivalent to: ```js f(par1, par2, parN) { let or const obj = { par1, par2 }; let or const obj2 = { parN }; } ``` \ \ [EDIT 2] We can go a step further. When more than one parameters has to be inserted into an object: ```js f(obj.par1, obj.par2, obj.parN) {} ``` we could write: ```js f(obj.{par1, par2, parN}) {} ```
andrysimo1997 at gmail.com (2018-11-29T09:05:14.077Z)
In costructor functions and in the constructor() method in ES6 classes is easily to fall in the following pattern: ``` F(par1, par2, ..., parN) { this.par1 = par1; this.par2 = par2; ... this.parN = parN; } ``` So my proposal is to avoid those repetitions by prefixing a dot `.` to each parameter: ```js F(.par1, .par2, ..., .parN) {} ``` Simple but quite useful. More info here: https://github.com/jfet97/proposal-fast-this-objects-assignments/ \ \ [EDIT] It could be a shortcut for: ```js F(this.par1, this.par2, ..., this.parN) {} ``` so we could create and initialize objects in a more general situation: ```js f(obj.par1, obj.par2, obj2.parN) {} ``` equivalent to: ```js f(par1, par2, parN) { let or const obj = { par1, par2 }; let or const obj2 = { parN }; } ``` \ \ [EDIT 2] We can go a step further. When more than one parameters has to be inserted into an object: ```js f(obj.par1, obj.par2, obj.parN) {} ``` we could write: ```js f(obj.{par1, par2, parN}) {} ```
andrysimo1997 at gmail.com (2018-11-29T09:04:54.100Z)
In costructor functions and in the constructor() method in ES6 classes is easily to fall in the following pattern: ``` F(par1, par2, ..., parN) { this.par1 = par1; this.par2 = par2; ... this.parN = parN; } ``` So my proposal is to avoid those repetitions by prefixing a dot `.` to each parameter: ```js F(.par1, .par2, ..., .parN) {} ``` Simple but quite useful. More info here: https://github.com/jfet97/proposal-fast-this-objects-assignments/ [EDIT] It could be a shortcut for: ```js F(this.par1, this.par2, ..., this.parN) {} ``` so we could create and initialize objects in a more general situation: ```js f(obj.par1, obj.par2, obj2.parN) {} ``` equivalent to: ```js f(par1, par2, parN) { let or const obj = { par1, par2 }; let or const obj2 = { parN }; } ``` [EDIT 2] We can go a step further. When more than one parameters has to be inserted into an object: ```js f(obj.par1, obj.par2, obj.parN) {} ``` we could write: ```js f(obj.{par1, par2, parN}) {} ```
andrysimo1997 at gmail.com (2018-11-29T09:04:03.896Z)
In costructor functions and in the constructor() method in ES6 classes is easily to fall in the following pattern: ``` F(par1, par2, ..., parN) { this.par1 = par1; this.par2 = par2; ... this.parN = parN; } ``` So my proposal is to avoid those repetitions by prefixing a dot `.` to each parameter: ```js F(.par1, .par2, ..., .parN) {} ``` Simple but quite useful. More info here: https://github.com/jfet97/proposal-fast-this-objects-assignments/ [EDIT] It could be a shortcut for: ```js F(this.par1, this.par2, ..., this.parN) {} ``` so we could create and initialize objects in a more general situation: ```js f(obj.par1, obj.par2, obj2.parN) {} ``` equivalent to: ```js f(par1, par2, parN) { let or const obj = { par1, par2 }; let or const obj2 = { parN }; } ``` [EDIT 2] We can go a step further. When more than one parameters has to be inserted into an object: ```js f(obj.par1, obj.par2, obj.parN) {} ``` we could write: ```js f(obj.{par1, par2, parN}) {} ```
andrysimo1997 at gmail.com (2018-11-29T08:53:52.072Z)
In costructor functions and in the constructor() method in ES6 classes is easily to fall in the following pattern: ``` F(par1, par2, ..., parN) { this.par1 = par1; this.par2 = par2; ... this.parN = parN; } ``` So my proposal is to avoid those repetitions by prefixing a dot `.` to each parameter: ```js F(.par1, .par2, ..., .parN) {} ``` Simple but quite useful. More info here: https://github.com/jfet97/proposal-fast-this-objects-assignments/ [EDIT] It could be a shortcut for: ```js F(this.par1, this.par2, ..., this.parN) {} ``` so we could create and initialize objects in a more general situation: ```js f(obj.par1, obj.par2, obj2.parN) {} ``` equivalent to: ```js f(par1, par2, parN) { let or const obj = { par1, par2 }; let or const obj2 = { parN }; } ```
andrysimo1997 at gmail.com (2018-11-28T22:42:56.128Z)
In costructor functions and in the constructor() method in ES6 classes is easily to fall in the following pattern: ``` F(par1, par2, ..., parN) { this.par1 = par1; this.par2 = par2; ... this.parN = parN; } ``` So my proposal is to avoid those repetitions by prefixing a dot `.` to each parameter: ```js F(.par1, .par2, ..., .parN) {} ``` Simple but quite useful. More info here: https://github.com/jfet97/proposal-fast-this-assignments [EDIT] It could be a shortcut for: ```js F(this.par1, this.par2, ..., this.parN) {} ``` so we could create and initialize objects in a more general situation: ```js f(obj.par1, obj.par2, obj2.parN) {} ``` equivalent to: ```js f(par1, par2, parN) { let or const obj = { par1, par2 }; let or const obj2 = { parN }; } ```
andrysimo1997 at gmail.com (2018-11-28T22:42:40.187Z)
In costructor functions and in the constructor() method in ES6 classes is easily to fall in the following pattern: ``` F(par1, par2, ..., parN) { this.par1 = par1; this.par2 = par2; ... this.parN = parN; } ``` So my proposal is to avoid those repetitions by prefixing a dot `.` to each parameter: ```js F(.par1, .par2, ..., .parN) {} ``` Simple but quite useful. More info here: https://github.com/jfet97/proposal-fast-this-assignments [EDIT] It could be a shortcut for: ```js F(this.par1, this.par2, ..., this.parN) {} ``` so we could create and initialize objects in a more general situation: ```js F(obj.par1, obj.par2, obj2.parN) {} ``` equivalent to: ```js F(par1, par2, parN) { let or const obj = { par1, par2 }; let or const obj2 = { parN }; } ```
andrysimo1997 at gmail.com (2018-11-28T22:42:18.332Z)
In costructor functions and in the constructor() method in ES6 classes is easily to fall in the following pattern: ``` F(par1, par2, ..., parN) { this.par1 = par1; this.par2 = par2; ... this.parN = parN; } ``` So my proposal is to avoid those repetitions by prefixing a dot `.` to each parameter: ```js F(.par1, .par2, ..., .parN) {} ``` Simple but quite useful. More info here: https://github.com/jfet97/proposal-fast-this-assignments [EDIT] It could be a shortcut for: ```js F(this.par1, this.par2, ..., this.parN) {} ``` so we could create and initialize objects in a general situation: ```js F(obj.par1, obj.par2, obj2.parN) {} ``` equivalent to: ```js F(par1, par2, parN) { let or const obj = { par1, par2 }; let or const obj2 = { parN }; } ```
andrysimo1997 at gmail.com (2018-11-28T22:42:06.036Z)
In costructor functions and in the constructor() method in ES6 classes is easily to fall in the following pattern: ``` F(par1, par2, ..., parN) { this.par1 = par1; this.par2 = par2; ... this.parN = parN; } ``` So my proposal is to avoid those repetitions by prefixing a dot `.` to each parameter: ```js F(.par1, .par2, ..., .parN) {} ``` Simple but quite useful. More info here: https://github.com/jfet97/proposal-fast-this-assignments [EDIT] It could be a shortcut for: ```js F(this.par1, this.par2, ..., this.parN) {} ``` so we could create and initialize objects in a general situation: ```js F(obj.par1, obj.par2, obj2.parN) {} ``` equivalent to: ```js F(par1, par2, parN) { let or const obj = { par1, par2 }; let or const obj2 = { parN }; } ```
andrysimo1997 at gmail.com (2018-11-28T22:41:18.344Z)
In costructor functions and in the constructor() method in ES6 classes is easily to fall in the following pattern: ``` F(par1, par2, ..., parN) { this.par1 = par1; this.par2 = par2; ... this.parN = parN; } ``` So my proposal is to avoid those repetitions by prefixing a dot `.` to each parameter: ```js F(.par1, .par2, ..., .parN) {} ``` Simple but quite useful. More info here: https://github.com/jfet97/proposal-fast-this-assignments [EDIT] It could be a shortcut for: ```js F(this.par1, this.par2, ..., this.parN) {} ``` so we could create and initialize objects in a general situation: ```js F(par1, par2, parN) { let or const obj = { par1, par2 }; let or const obj2 = { parN }; } ``` equivalent to:
andrysimo1997 at gmail.com (2018-11-28T19:16:45.241Z)
In costructor functions and in the constructor() method in ES6 classes is easily to fall in the following pattern: ``` F(par1, par2, ..., parN) { this.par1 = par1; this.par2 = par2; ... this.parN = parN; } ``` So my proposal is to avoid those repetitions by prefixing a dot `.` to each parameter: ```js F(.par1, .par2, ..., .parN) {} ``` Simple but quite useful. More info here: https://github.com/jfet97/proposal-fast-this-assignments
andrysimo1997 at gmail.com (2018-11-28T19:15:02.721Z)
In costructor functions and in the constructor() method in ES6 classes is easily to fall in the following pattern: ``` F(par1, par2, ..., parN) { this.par1 = par1; this.par2 = par2; ... this.parN = parN; } ``` So my proposal is to avoid those repetitions by prefixing a dot `.` to each parameter: ```js F(.par1, .par2, ..., .parN) {} ``` Simple but quite useful. More info here: https://github.com/jfet97/proposal
andrysimo1997 at gmail.com (2018-11-28T18:39:14.894Z)
In costructor functions and in the constructor() method in ES6 classes is easily to fall in the following pattern: ```js F(par1, par2, ..., parN) { this.par1 = par1; this.par2 = par2; ... this.parN = parN; } ``` So my proposal is to avoid those repetitions by prefixing a dot `.` to each parameter: ```js F(.par1, .par2, ..., .parN) {} ``` Simple but quite useful. More info here: https://github.com/jfet97/proposal
andrysimo1997 at gmail.com (2018-11-28T18:38:55.806Z)
In costructor functions and in the constructor() method in ES6 classes is easily to fall in the following pattern: ```js F(par1, par2, ..., parN) { this.par1 = par1; this.par2 = par2; ... this.parN = parN; } ``` So my proposal is to avoid those repetitions by prefixing a dot *.* to each parameter: ```js F(.par1, .par2, ..., .parN) {} ``` Simple but quite useful. More info here: https://github.com/jfet97/proposal