Javascript 在ES6中声明新阵列？这是干什么的

有人能给我解释一下这是怎么回事吗

[blog.id]: blog

> c = {a, b}                    
{ a: 1, b: 2 }                  

我假设它正在创建一个新数组，其中

blog.id

作为一个元素，示例id/key为4，blog是与该元素相等的内容集

 export default function(state = {}, action) {
      switch (action.type) {
        case FETCH_BLOG:
          const blog = action.payload;
          return { ...state, [blog._id]: blog };
        case FETCH_BLOGS:
          return { ...state, ...mapKeys(action.payload, '_id') };
        default:
          return state;
      }
    }

> c = {a, b}                    
{ a: 1, b: 2 }                  

---

它是一个计算属性键：和

> c = {a, b}                    
{ a: 1, b: 2 }                  

它创建一个新对象，其中包含

state

拥有的所有键/值（这就是

…state

所做的），该键的名称是属性

blog.\u id

的解析，其值是

blog

> c = {a, b}                    
{ a: 1, b: 2 }                  

因此，如果

blog.\u id

是

“foo”

，

blog

是

“bar”

> c = {a, b}                    
{ a: 1, b: 2 }                  

返回的对象是：

{
  "all": "the",
  "key": "vals",
  "state": "had",

  // along with the new key/val
  "foo": "bar"
}

> c = {a, b}                    
{ a: 1, b: 2 }                  

---

它是一个计算属性键：和

> c = {a, b}                    
{ a: 1, b: 2 }                  

它创建一个新对象，其中包含

state

拥有的所有键/值（这就是

…state

所做的），该键的名称是属性

blog.\u id

的解析，其值是

blog

> c = {a, b}                    
{ a: 1, b: 2 }                  

因此，如果

blog.\u id

是

“foo”

，

blog

是

“bar”

> c = {a, b}                    
{ a: 1, b: 2 }                  

返回的对象是：

{
  "all": "the",
  "key": "vals",
  "state": "had",

  // along with the new key/val
  "foo": "bar"
}

> c = {a, b}                    
{ a: 1, b: 2 }                  

---

这是一种新的更方便的ES6语法：

c:\srv> node                    
> blog = {_id:42}               
{ _id: 42 }                     

> c = {a, b}                    
{ a: 1, b: 2 }                  

这不起作用：

> {blog._id: blog}              
({blog._id: blog})              
      ^                         

SyntaxError: Unexpected token . 

> c = {a, b}                    
{ a: 1, b: 2 }                  

但将其包含在

[]

中会：

> {[blog._id]: blog}            
{ '42': { _id: 42 } }           

> c = {a, b}                    
{ a: 1, b: 2 }                  

另一种语法是dict解包。让我们做两个变量：

> a = 1; b = 2                  
2                               

> c = {a, b}                    
{ a: 1, b: 2 }                  

而不是

c={a:a，b:b}

> c = {a, b}                    
{ a: 1, b: 2 }                  

…

允许您从dict复制所有属性：

> c = {a, b}                    
{ a: 1, b: 2 }                  

> {...c}                        
{ a: 1, b: 2 }                  

所以这条线

> c = {a, b}                    
{ a: 1, b: 2 }                  

return { ...state, [blog._id]: blog };

复制

状态

对象中的所有内容，并添加一个带有键

blog.\u id

和值

blog

的字段。类似于

> c = {a, b}                    
{ a: 1, b: 2 }                  

const res = {};
for (const attr of state) {
    res[attr] = state[attr];
}
res[blog._id] = blog;
return res;

---

这是一种新的更方便的ES6语法：

c:\srv> node                    
> blog = {_id:42}               
{ _id: 42 }                     

> c = {a, b}                    
{ a: 1, b: 2 }                  

这不起作用：

> {blog._id: blog}              
({blog._id: blog})              
      ^                         

SyntaxError: Unexpected token . 

> c = {a, b}                    
{ a: 1, b: 2 }                  

但将其包含在

[]

中会：

> {[blog._id]: blog}            
{ '42': { _id: 42 } }           

> c = {a, b}                    
{ a: 1, b: 2 }                  

另一种语法是dict解包。让我们做两个变量：

> a = 1; b = 2                  
2                               

> c = {a, b}                    
{ a: 1, b: 2 }                  

而不是

c={a:a，b:b}

> c = {a, b}                    
{ a: 1, b: 2 }                  

…

允许您从dict复制所有属性：

> c = {a, b}                    
{ a: 1, b: 2 }                  

> {...c}                        
{ a: 1, b: 2 }                  

所以这条线

> c = {a, b}                    
{ a: 1, b: 2 }                  

return { ...state, [blog._id]: blog };

复制

状态

对象中的所有内容，并添加一个带有键

blog.\u id

和值

blog

的字段。类似于

> c = {a, b}                    
{ a: 1, b: 2 }                  

const res = {};
for (const attr of state) {
    res[attr] = state[attr];
}
res[blog._id] = blog;
return res;

---

它是一个计算属性键：不，它将

blog

对象分配给state对象中的

blog\u id

属性。如果

blog.\u id

包含

123

作为值，state=state={…，123:[object]}就很容易检查它在做什么，因为它是代码，你可以在本地（像Chrome，NodeJS这样的浏览器）或是一个浏览器上运行它。这样你就不必假设，你只需要知道。您可能仍然需要弄清楚它的调用，但至少您不必假设结果是什么。它是一个计算属性键：不，它正在将

blog

对象分配给state对象中的

blog\u id

属性。如果

blog.\u id

包含

123

作为值，state=state={…，123:[object]}就很容易检查它在做什么，因为它是代码，你可以在本地（像Chrome，NodeJS这样的浏览器）或是一个浏览器上运行它。这样你就不必假设，你只需要知道。你可能仍然需要弄清楚它叫什么，但至少你不必假设结果是什么。用一个很好的例子给出清晰的答案。很好的解释，谢谢！用一个很好的例子清楚地回答。很好的解释，谢谢！谢谢你的努力，解释了它，但是上面的答案用一个更好的例子更清楚。谢谢你的努力，解释了它，但是上面的答案用一个更好的例子更清楚。