标签: destructuring

如何编写一个函数,在ES6中以最紧凑的方式只占用少量属性？

我已经提出了使用解构+简化对象文字的解决方案,但我不喜欢在代码中重复的字段列表.

有更薄的解决方案吗？

(v) => {
    let { id, title } = v;
    return { id, title };
}

不确定这是否是特定于Mozilla的JS语法,但我经常发现变量是以这种方式声明的,例如,在附加SDK文档中:

var { Hotkey } = require("sdk/hotkeys");

并在各种chrome Javascript(let声明被用来代替var),

let { classes: Cc, interfaces: Ci, results: Cr, utils: Cu }  = Components;

我发现它很混乱但我无法找到任何关于语法的文档,即使在MDN上也是如此.

例如,如果我有两个对象:

var foo = {
  x: "bar",
  y: "baz"
}

和

var oof = {}

我想将x和y值从foo转移到oof.有没有办法使用es6解构语法？

也许是这样的:

oof{x,y} = foo

在coffeescript中这很简单:

coffee> a = ['a', 'b', 'program']
[ 'a', 'b', 'program' ]
coffee> [_..., b] = a
[ 'a', 'b', 'program' ]
coffee> b
'program'

es6是否允许类似的东西？

> const [, b] = [1, 2, 3]                              
'use strict'                                           
> b  // it got the second element, not the last one!                      
2                                                      
> const [...butLast, last] = [1, 2, 3]          
SyntaxError: repl: Unexpected token (1:17)                                                                                                                                                        
> 1 | const [...butLast, last] = [1, 2, 3]                                                                                                                                                        
    |                  ^                                                                                                                                                                          
    at Parser.pp.raise (C:\Users\user\AppData\Roaming\npm\node_modules\babel\node_modules\babel-core\node_modules\babylon\lib\parser\location.js:24:13)                                           

当然我可以用es5方式做到 -

const …

在Python 2和Python 3等其他语言中,您可以为元组变量定义和赋值,并检索它们的值,如下所示:

tuple = ("Bob", 24)
name, age = tuple
print(name)           #name evaluates to Bob
print(age)            #age evaluates to 24

JavaScript中有类似的东西吗？或者我只需要用数组的丑陋方式来做:

tuple = ["Bob", 24]
name = tuple[0]       //name Evaluates to Bob
age = tuple[1]        //age Evaluates to 24

有没有更好的方法来模拟JavaScript 5中的Python元组？

最近的视频声称EMCAScript 6解构已在Node.JS中部分实现.我尝试了各种例子(使用v0.10.12和--harmony标志),例如

var [a, b] = [1, 2];

和

var {a: a, b: b} = {a: 1, b: 2};

无济于事.此票证似乎表明V8尚未支持解构.

在Node.JS中,解构是否真的部分实现了？我可以使用的代码片段是什么？

这个

const { foo: IFoo[] } = bar;

还有这个

const { foo: Array<IFoo> } = bar;

会合理地导致错误.

还有这个

const { foo: TFoo } = bar;

将只是破坏TFoo财产.

如何为析构化对象属性指定类型？

我试图理解下面两个require语句之间的区别.

具体来说,{ }s缠绕的目的是什么ipcMain？

const electron = require('electron')

const {ipcMain} = require('electron')

它们似乎都分配了电子模块的内容,但它们的功能明显不同.

任何人都能解释一下吗？

以前我总是记录我的对象参数如下:

/**
 * Description of the function
 *
 * @param {Object} config - The configuration
 * @param {String} config.foo
 * @param {Boolean} [config.bar] - Optional value
 * @return {String}
 */
function doSomething (config = {}) {
  const { foo, bar } = config;
  console.log(foo, bar);
  // do something
}

但我不确定desctructured函数参数的最佳方法是什么.我是否只是忽略了对象,以某种方式定义它或者记录它的最佳方式是什么？

/**
 * Description of the function
 *
 * @param {String} foo
 * @param {Boolean} [bar] - Optional value
 * @return {String}
 */
function doSomething ({ foo, bar } = {}) …

什么是更短的版本？:

from = hash.fetch(:from)
to = hash.fetch(:to)
name = hash.fetch(:name)
# etc

请注意fetch,如果密钥不存在,我想引发错误.

必须有更短的版本,例如:

from, to, name = hash.fetch(:from, :to, :name) # <-- imaginary won't work

如果需要,可以使用ActiveSupport.