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-assignmentsandrysimo1997 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/proposalandrysimo1997 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/proposalandrysimo1997 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
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: F(.par1, .par2, ..., .parN) {} Simple but quite useful. More info here: https://github.com/jfet97/proposal-fast-this-assignments -------------- next part -------------- An HTML attachment was scrubbed... URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20181128/0172cfcd/attachment-0001.html>