es6的解構是什麼意思

在es6中，解構指的是依照一定的模式從陣列和物件中提取值，對變數進行賦值的行為；常見的有物件結構、陣列解構和混合解構，是一種將數據結構分解成更小的部分的過程，從而達到簡化提取資訊的目的。

本教學操作環境：windows10系統、ECMAScript 6.0版、Dell G3電腦。

es6的解構是什麼意思

destructuring：百度百科的意思是結構分解，ES6 中允許按照一定模式，從數組和物件中提取值，對變數進行賦值，這被稱為解構（Destructuring）。

開發中較常見的有物件解構、 陣列解構、混合解構。這是一種將資料結構分解為更小的部分的過程，從而達到簡化提取資訊的目的。

物件解構

傳統方法取得物件中的值

let node = {
    type: 'Identifier',
    name: 'foo'
}
console.log(node.type) // Identifier
console.log(node.foo) // foo

使用解構

let node = {
    type: 'Identifier',
    name: 'foo'
}
let { type, name } = node
console.log(type) // Identifier
console.log(name) // foo

如果指定的局部變數名稱在物件中不存在，那麼這個局部變數會被賦值為undefined

let { type, name, value } = node
console.log(type) // Identifier
console.log(name) // foo
console.log(value) // undefined

當指定的屬性不存在時,可以給不存在的屬性定義任意的預設值

let { type, name, value = true } = node
console.log(type) // Identifier
console.log(name) // foo
console.log(value) // true

指定新的變數名稱進行解構賦值

let arr = {
  six: '男',
  age: 19
}
let {six:newSix, age:newAge} = arr
console.log(six, age) // six is not defined
console.log(newSix, newAge) // 男 19

看上面是不是覺得很奇怪，傳統物件賦值都是左邊四屬性，右邊是值。但是在解構寫法中右邊是屬性，左邊是值，所以新的變數名稱在右邊。

如果使用let、var、const對物件進行解構時，被解構物件的值就不能不存在。

不使用var、let、const賦值時，需要將解構語句使用（）進行包裹

（{type，name} = node);//{}在js中作為程式碼區塊，單獨使用加等號會報錯會報錯

嵌套物件解構

在物件嵌套物件中解構，我們會在第一層解構中繼續使用花括號來深入下一層進行查找；我們先來找出一個栗子：

let node = {
    type: "Identifier",
    name: "foo",
    loc: {
        start: {
            line: 1,
            column: 1
        },
        end: {
            line: 1,
            column: 4
        }
    }
}

上面是一個嵌套物件node，我們先解構第一層

let { loc, type, name } = node // {} Identifier foo

可以看到我們特意打亂了{}中屬性的順序，結果仍然正確輸出，所以可以猜到具體的對應方式應該是根據名字來對應的，和順序無關。

繼續解構第二層

let { loc: { start }} = node;
console.log(start.line); // 1
console.log(start.column); // 4

這裡我們也可以將start賦值給一個新的自訂的局部變量，假設我們賦值給newStart

let { loc: { start: newStart }} = node
console.log(newStart.line) // 1
console.log(newStart.column) // 4

總結如下：

所有冒號前的識別碼都代表在物件中的檢索位置，其右側為被賦值的變數名稱；如果冒號後面是花括號，則表示要賦予的最終值嵌套在物件內部更深的層級中。

陣列解構

陣列解構使用的是陣列字面量，且解構運算全部在陣列內完成，且陣列解構不需要像物件字面量語法一樣使用對象的命名屬性。

let colors = [ 'red', 'green', 'blue' ]
let [ firstColor, secondColor ] = colors
console.log(firstColor) // 'red'
console.log(secondColor) // 'green'

陣列解構語法中，我們主要是透過值在陣列中的位置進行選取，且可以將其儲存在任意變數中，未顯示宣告的元素會直接被忽略。

let [ , , thirdColor ] = colors
console.log(thirdColor) // 'blue'

數組解構之變量交換

傳統ES5中互換值一般需要引入第三個臨時變量作為中轉，但如果使用數組解構賦值語法，就不需要在增加額外變量了。

// ES5中互换值：
 let a = 1, b = 2, tmp;
 tmp = a
 a = b
 b = tmp
 console.log(a, b) // 2, 1
 // ES6中互换值
 let a = 1, b = 2;
 [ a, b ] = [b, a]
 console.log(a, b) // 2, 1

嵌套資料解構

 let colors = [ 'red', [ 'green', 'lightgreen'], 'blue' ]
 let [ firstColor, [ secondColor, thirdColor ], fourthColor ] = colors
 console.log(firstColor) // red
console.log(secondColor) // green
console.log(thirdColor) // lightgreen
console.log(fourthColor) // blue

預設值

也可以在陣列解構賦值表達式中為陣列中的任意位置新增預設值，當指定位置的屬性不存在或其值為undefined時使用預設值

let colors = [ 'red' ]
let [ firstColor, secondColor = 'green' ] = colors
console.log(firstColor) // red
console.log(secondColor) // green

不定元素

...為展開運算子我們應該都知道它的用途，操作數組時可以用來把數組展開成字串。在陣列解構中，可以透過...語法將陣列中的其餘元素賦值給一個特定的變數。

let colors = [ 'red', 'green', 'blue' ]
let [ firstColor, ...restColors ] = colors
console.log(firstColosr) // 'red'
console.log(restColors.length); // 2
console.log(restColors[0]); // "green"
console.log(restColors[1]); // "blue"

陣列複製

在ES5中，開發者經常使用concat()方法來複製陣列

var colors = [ "red", "green", "blue" ];
var clonedColors = colors.concat();
console.log(clonedColors); //"[red,green,blue]"

concat()方法的設計初衷是連接兩個陣列，如果呼叫時不傳遞參數就會傳回目前函數的副本

在ES6中，可以透過不定元素的語法來實現相同的目標

let colors = [ "red", "green", "blue" ];
let [ ...clonedColors ] = colors;
console.log(clonedColors); //"[red,green,blue]"

在被解構的陣列中，不定元素必須為最後一個條目，在後面繼續添加逗號會導致程式拋出語法錯誤。

混合解構

let err = {
    errors: [
        {
            msg: 'this is a message'
        },
        {
            title: 'this is a title'
        }
    ]
}

上面的程式碼中，err對象包含errors，errors又是一個陣列又包含新的對象，擷取物件中的msg。我們可以將上述栗子一步一步拆開來解構：

let { errors } = err
let [ firstArr ] = errors
let { msg } = firstArr
console.log(msg) // 'this is a message'
也可以这样解构
let [ , { title }] = err.errors
console.log(title) // 'this is a title'
let [{ msg }] = err.errors
console.log(msg) // 'this is a message'

來看一個更複雜一點的，其實只要會找順序，這個理解起來還是很簡單的。

let node = {
    type: "Identifier",
    loc: {
      start: {
      line: 1,
      column: 1
       }
    },
    range: [0, 3]
};
let {
    loc: { start },
    range: [ startIndex ]
  } = node;
console.log(start.line); // 1
console.log(start.column); // 1
console.log(startIndex); // 0

實際使用- 參數解構

一般用在封裝函數參數的情況，如下栗子：

// options 上的属性表示附加参数
function setCookie(name, value, options) {
       options = options || {};
       let secure = options.secure,
       path = options.path,
       domain = options.domain,
       expires = options.expires;
       // 设置 cookie 的代码
}
//可以改写为：对options进行解构并赋予默认值
function setCookie(name, value, { secure, path, domain, expires } = {}) {
// ...
}

【相關推薦：javascript影片教學 、web前端】

#

以上是es6的解構是什麼意思的詳細內容。更多資訊請關注PHP中文網其他相關文章！