标签: destructuring

ES6的新解构分配功能现在已经众所周知(Babel的REPL上的实时副本); 在已存在的变量的情况下:

let a, b;                 // Existing variables
let o = {a: "a", b: "b"}; // An object to get values from
// ...
({a, b} = o);             // Set them to the props from `o`
console.log(a);           // "a"
console.log(b);           // "b"

ES6中是否有简单的说法？基于具有相同名称的变量设置现有对象的属性？(除了显而易见的o.a = a; o.b = b;)

注意我不是在讨论创建对象时,我们可以使用美妙的新对象初始化器语法来实现这一点,这样我们就不会不必要地重复这些名称:

let a = "a";
let b = "b";
let o = {a, b};

但是如果我已经有了一个对象,我可以在ES6中进行某种结构分配吗？

我以为我理解了解构,但我正在阅读一个clojure博客,这让我很困惑.如果你有一个像这样的函数:

(defn f [& {:keys [foo bar]}] 
  (println foo " " bar))

你为什么这样称呼它:

(f :foo 1 :bar 2)

我的第一个想法是我的函数应该像这样调用:

(f {:foo 1 :bar 2})
IllegalArgumentException No value supplied for key: {:foo 1, :bar 2}  clojure.lang.PersistentHashMap.createWithCheck (PersistentHashMap.java:89)

但显然这不起作用.我认为这与&工作方式有关.但是我一直认为它之后的东西是一个向量,因此你必须在它之后像向量一样去构造任何东西.

有人可以向我解释这个定义是如何/为什么以它的方式工作的？谢谢

当查看解构元素的推断类型时，它将假设数组永远不为空。

const x: number[] = [];
const [first] = x; // first inferred as number

console.log(first); // undefined

if (first !== undefined) {
    // ...
}

游乐场链接

例如，这会导致 TSLint 规则“strict-type-predicates”出现一个有趣的行为，它将把 if 语句标记为始终为真，而实际上并非如此。

我是否遗漏了一些东西，这是正常行为？

我收到以下错误：

type Union = { type: "1"; foo: string } | { type: "2"; bar: number };

function doSomething = (object: Union) => {
  const { foo } = object
  //      ^ TS2339: Property 'foo' does not exist on type 'Union'.
  console.log(object.bar)
  //                 ^ TS2339: Property 'bar' does not exist on type 'Union'.
}

期望的结果：

typeof foo === string | undefined
typeof bar === number | undefined

如何在没有显式类型保护的情况下访问属性，例如：

const foo = o.type === 1 ? o.foo : undefined
const bar …

我使用带有babel编译器的ES6功能.我有一个函数,它将选项对象作为参数:

function myFunction({ option1 = true, option2 = 'whatever' }) {
    console.log(option1, option2);
    // do something...
}

当我打电话给它时,解构就会发生,一切运转良好.我想在大多数时候用默认选项调用它,所以我这样做:

myFunction({}); // true 'whatever'

但它看起来有点奇怪.只要打电话就会更清洁:

myFunction(); // TypeError: Cannot read property 'option1' of undefined

可能吗？

您可以使用解构分配来定义ES6中的枚举,如下所示:

var [red, green, blue] = [0, 1, 2];

相反,我希望解构分配的右侧是动态的.例如:

var MAX_ENUM_SIZE = 32;
var ENUM = new Array(MAX_ENUM_SIZE);
for (var i = 0; i < MAX_ENUM_SIZE; i++) ENUM[i] = i;

var [red, green, blue] = ENUM;

不幸的是,这似乎是一个黑客.如果我希望将来有更大的枚举怎么办？因此,我正在考虑使用迭代器进行解构赋值,如下所示:

var [red, green, blue] = enumeration(/* I don't want to specify size */);

但是,我不认为可以使用迭代器进行解构赋值^{[需要引证]}.有没有办法实现这个目标？

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

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

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

编写之间是否存在性能差异（如果有）

const color = props.color;

与

const { color } = props;

另外，如果我们在参数签名中进行结构分解，会获得或失去任何性能？参见example3

我假设在这种情况下example3是编写函数的最佳方法？

功能性反应组件示例：

const example1 = (props) => {
  const color = props.color;
  // I know I could also just write style={{ color: props.color }}
  // but for arguments sake lets say I want to write it like this.
  return <h1 style={{ color }}>Hello</h1>;
};

const example2 = (props) => {
  const { color } = props;
  return <h1 style={{ color }}>Hello</h1>;
};

const example3 = ({ color …

我在mongodb连接的变量赋值中得到一个TypeError.这有解决方法吗？

//server.js
var mongoose = require('mongoose');
var config = require('./config');

var { db: {user,pass,host,port,name } } = config;

var connectionString = `mongodb://${user}:${pass}@${host}:${port}/${name}`;

mongoose.connect(connectionString, { useMongoClient: true });

错误

C:\mean\webguidv1\server.js:65
  db: {
  ^

TypeError: Cannot destructure property `db` of 'undefined' or 'null'.

这是我的config.js文件

// config.js
var env = process.env.NODE_ENV; // 'dev' or 'test'

var dev = { app: { port: 3000 }, db: {user: '', pass: '', host: '', port: , name: '' }};

var test = { app: { port: …

&代码中的目的是什么&i in list？如果我删除&，则会在 中产生错误largest = i，因为它们的类型不匹配（其中iis&32和iis i32）。但是如何&i转换i为i32？

fn largest(list: &[i32]) -> i32 {
    println!("{:?}", list);
    let mut largest = list[0];
    for &i in list {
        if i > largest {
            largest = i;
        }
    }
    largest
}

fn main() {
    let hey = vec![1, 3, 2, 6, 90, 67, 788, 12, 34, 54, 32];
    println!("The largest number is: {}", largest(&hey)); …