DIV CSS 佈局教程網

深入淺出講解 ES6 解構賦值(Destructuring)
編輯:JavaScript基礎知識     

什麼是解構

解構是構造的逆向操作。它不是把值組裝成新的對象或數組,而是把既有的結構拆開,取出你需要的部分。

ES6 引入了一套「模式」語法:模式描述了你想要提取的形狀,它會映射被解構的數據結構,只有與模式匹配的數據才會被提取出來。被解構的數據寫在賦值號 = 右側,可以是數組與對象的任意嵌套組合;左側變量個數不限。

數組解構

數組解構按位置匹配:模式必須與數組結構對應,每個變量拿到同位置上的值。

全部取出

const avengers = ['Tony Stark', 'Steve Rogers', 'Natasha Romanoff'];
const [ironMan, cap, blackWidow] = avengers;
// ironMan = 'Tony Stark'
// cap = 'Steve Rogers'
// blackWidow = 'Natasha Romanoff'

跳過某個位置——留一個空洞即可:

const avengers = ['Tony Stark', 'Steve Rogers', 'Natasha Romanoff'];

const [, cap, blackWidow] = avengers;      // 跳過第一項
const [ironMan, , blackWidow2] = avengers; // 跳過第二項
const [ironMan2, cap2] = avengers;         // 只取前兩項,第三項忽略

嵌套數組:只要左側模式與右側結構對應,嵌套多少層都能解構。

const avengers = [
  'Natasha Romanoff',
  ['Tony Stark', 'James Rhodes'],
  ['Steve Rogers', 'Sam Wilson']
];

const [blackWidow, [ironMan, warMachine], [cap, falcon]] = avengers;
// warMachine = 'James Rhodes'

深層取值:用連續的逗號跳過不需要的層級。

const avengers = [
  'Natasha Romanoff',
  [['Tony Stark', 'Pepper Potts'], 'James Rhodes'],
  ['Steve Rogers', 'Sam Wilson']
];

// 取出 'Pepper Potts'
const [, [[, hera]]] = avengers;
// hera = 'Pepper Potts'

rest 操作符收集剩餘項:

const avengers = ['Natasha Romanoff', 'Tony Stark', 'Steve Rogers'];
const [blackWidow, ...theOthers] = avengers;
// theOthers = ['Tony Stark', 'Steve Rogers']

對象解構

規則與數組相同,只是匹配依據從位置變成了屬性名。你既要指出想取哪個屬性,也要給出接收值的變量名。

基本形式

const { ironMan: a } = { ironMan: 'Tony Stark' };
// a = 'Tony Stark'

一次取多個屬性

const avengers = {
  ironMan: 'Tony Stark',
  cap: 'Steve Rogers',
  blackWidow: 'Natasha Romanoff'
};

const { ironMan: a, cap: b, blackWidow: c } = avengers;

嵌套對象:層級再深也照樣成立。

const avengers = {
  blackWidow: 'Natasha Romanoff',
  ironManCharacters: {
    couple: { ironMan: 'Tony Stark', hera: 'Pepper Potts' },
    partner: { warMachine: 'James Brodie' }
  },
  capCharacters: {
    cap: 'Steve Rogers',
    partner: { falcon: 'Sam Wilson' }
  }
};

const {
  blackWidow: a,
  ironManCharacters: {
    couple: { ironMan: b, hera: c },
    partner: { warMachine: d }
  },
  capCharacters: {
    cap: e,
    partner: { falcon: f }
  }
} = avengers;

變量命名的簡寫

用 a, b, c 命名毫無意義。完整寫法是 { ironMan: ironMan },但當屬性名與變量名相同時,可以只寫一次:

const avenger = { ironMan: 'Tony Stark' };
const { ironMan } = avenger;   // 等價於 { ironMan: ironMan }
// ironMan = 'Tony Stark'

於是常見寫法就變成了:

const avengers = {
  ironMan: 'Tony Stark',
  cap: 'Steve Rogers',
  blackWidow: 'Natasha Romanoff'
};
const { ironMan, cap, blackWidow } = avengers;

深層屬性同理,只要把路徑映射清楚:

const { ironManCharacters: { couple } } = avengers;
// couple = { ironMan: 'Tony Stark', hera: 'Pepper Potts' }

注意這裡的 couple 用了簡寫,完整形式是 { ironManCharacters: { couple: couple } }。如果只寫 const { couple } = avengers;,是取不到值的——引擎需要沿著屬性路徑逐層查找。

賦值給已有對象的屬性

const avengers = {
  blackWidow: 'Natasha Romanoff',
  ironManCharacters: {
    couple: { ironMan: 'Tony Stark', hera: 'Pepper Potts' }
  }
};

const ironManProperties = { family: {} };

({ ironManCharacters: { couple: ironManProperties.family } } = avengers);

ironManProperties.family;
// { ironMan: 'Tony Stark', hera: 'Pepper Potts' }

這裡有兩個關鍵點:

1. 必須用圓括號包住。因為我們是在給已存在的變量賦值,而不是聲明新變量。

2. 模式依然要匹配。{ ironManCharacters: { couple ... } } 對應 avengers 的結構不變,只是原來放變量的位置換成了目標對象的屬性。

默認值

const avengers = {
  ironMan: 'Tony Stark',
  cap: 'Steve Rogers',
  blackWidow: 'Natasha Romanoff'
};

const {
  ironMan,
  cap,
  blackWidow,
  theHulk = 'Bruce Banner'   // 對象中沒有該屬性,使用默認值
} = avengers;

容易踩的幾個坑

坑一:給已聲明的變量解構時忘了加括號

不能對已聲明的變量直接解構,也就是說解構必須與聲明同時發生:

const { ironMan } = avengers;      // 合法
let { cap } = avengers;            // 合法
var { blackWidow } = avengers;     // 合法

let theHulk;
{ theHulk } = avengers;            // 報錯

原因很簡單:以花括號開頭時,JS 會把它當成一個代碼塊(block)來解析。解法是用圓括號包起來:

let theHulk;
({ theHulk } = avengers);   // theHulk = 'Bruce Banner'

坑二:試圖直接 return 一個解構表達式

// 這樣寫不對
function getTonyStark(avengers) {
  return { ironMan: { realName } } = avengers;
  // 返回的是整個 avengers 對象,而不是 realName
}

必須先賦給變量,再返回:

function getTonyStark(avengers) {
  const { ironMan: { realName } } = avengers;
  return realName;
}

實在不想拆成兩行,也可以借助短路求值寫成一條:

function getTonyStark(avengers) {
  return ({ ironMan: { realName } } = avengers) && realName;
}

因為 && 會返回決定結果的那個操作數:左側是賦值表達式,右側的 realName 就是最終返回值。能跑,但可讀性不划算——追求簡短的同時別忘了代碼是寫給人看的。

總結

解構的核心只有一句:在賦值號左側畫出數據的形狀,右側的數據按這個形狀被拆解。它不僅能削減代碼量,還會改變你組織數據與函數參數的方式。尤其在處理接口返回的嵌套 JSON 時,解構能讓取值意圖一目了然。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved