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}}调用时{1}}只会[1] a 0，x frame。{/}

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

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

请参阅：

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实现可以做的最好的事情是访问嵌套的道具，而不是对象本身的引用以及嵌套的道具。

（虽然我很想证明这是错误的，但这也是我所寻求的一项功能）

Answer 3

对于嵌套对象解构，您可以使用赋值运算符来提取嵌套的引用值。

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

同样，您可以解析函数调用者

const f = ({ o,a=o.a } = {a:y}) => {
    console.log(o)
    console.log(a)
};

f({o:{a: 0 }});

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

3 个答案: