在保留对象的同时解析函数调用中的赋值

Question

有没有办法做以下的事情？

f = (o:{a:x}) {
    console.log(o);
    console.log(x);
}
f({a:0});
//Should Print:
//{a:0}
//0

获得与此相同的结果.

f = function(o) {
    var {a:x} = o;
    console.log(o);
    console.log(x);
}
f({a:0});
//Prints
//{a:0}
//0

我想解析函数参数中的对象,同时将对象传递给函数,以便可以修改对象.

Answer 1

TL; DR

对象 - 丢失属性:

let f = ({ a: x, ...o }) => {
    console.log(o);
    console.log(x);
};
f({ a: 0, b: 1, c: 2 });
// x is: 0
// o is: { b: 1, c: 2 }

对象 - 保留属性:

let f = (o) => {
    let { a: x } = o;
    console.log(o);
    console.log(x);
};
f({ a: 0, b: 1, c: 2 });
// x is: 0
// o is: { a: 0, b: 1, c: 2 }

数组 - 丢失元素:

let f = ([x, ...a]) => {
    console.log(a);
    console.log(x);
};
f([0, 1, 2]);
// x is: 0
// a is: [1, 2]

数组 - 保留元素:

let f = (a) => {
    let [x] = a;
    console.log(a);
    console.log(x);
};
f([0, 1, 2 ]);
// x is: 0
// a is: [0, 1, 2]

请注意,上面保留属性的示例将相同的对象放在调用函数时使用的o(或数组中a),而不是副本.要使用浅表副本,您可以使用以下示例:

对象 - 保留属性,创建新对象:

let f = ({ ...o }) => {
    let { a: x } = o;
    console.log(o);
    console.log(x);
};
f({ a: 0, b: 1, c: 2 });
// x is: 0
// o is: { a: 0, b: 1, c: 2 }

数组 - 保留元素,创建一个新数组:

let f = ([...a]) => {
    let [x] = a;
    console.log(a);
    console.log(x);
};
f([0, 1, 2]);
// x is: 0
// a is: [1, 2]

说明

如果你想保留原始对象的所有属性,o那么你需要在函数体中进行显式的解构步骤:let { a: x } = o;但是如果你只想保留那些没有放入的属性x那么你可以使用如下所述的解构(将来支持它时).见例如下面的详细资料.

请注意,我最初假设您需要解构,就像解构数组时一样 - 但也许这不是您想要的 - 感谢Karen Grigoryan在评论中指出它.

逻辑上应该工作的语法不是这样的:

let f = (o: { a: x }) => {
    console.log(o);
    console.log(x);
};

但是这个:

let f = ({ a: x, ...o }) => {
    console.log(o);
    console.log(x);
};

(但如果它在今天的任何平台上或者甚至在转换器中本地工作,我都会感到非常惊讶.这需要支持对象解构中的rest操作符以及从作为函数参数传递的对象中解压缩字段.理论上没有理由它不应该'工作.实际上可能没有.)

需要注意的是({ a: x, ...o }) => ...,当援引为f({ a: 0, b: 1 })将只放{ b: 1 }中o,并会提出0的x-就像([x, ...a]) => ...当援引为f([0, 1])将只放[1]中a,并会提出0的x.

这意味着使用带有rest参数的解构 - 对于对象和数组 - 不会将整个数组或对象保留在rest变量中,而只保留那些未明确捕获的数据.

这意味着无论您是解构数组还是对象,都需要在函数体中放置显式解构步骤,而不是依赖于参数语法,如果您希望原始数组或对象保持原样.

看到:

• MDN上的Rest_in_Object_Destructuring

Answer 2

不,这是不可能的,考虑:

var obj = {a:0}

function f (o: {a:x}) {} // not valid - unexpected token :
function f ({a}) {} // valid a === 0
function f ({a:x}) {} // valid x === 0, a is undefined - probably no use for this

使用ES6实现可以做的最好的事情是访问嵌套的道具,而不是对象本身的引用以及嵌套的道具.

(虽然我很想证明这是错误的,这也是我一直在寻找的功能)