ES6解构赋值: ES6... :ES6三点

es6的特性，主要用于 数组和对象的析构

直接上问题: 

因为chrome低版本(用的55版本)不支持es6...的下面这种写法,

需要转为es5写法

 function calcLinePaths() {
        .
        .
        .
        . // 省略以上代码
          return { 
            ...item,
            path,
            key,
            d,
            time
          };
     }

改变写法:

 function calcLinePaths() {
        .
        .
        .
        . // 省略以上代码
        let _qw = { path,
              key,
              d,
              time};
          return _extends({}, item, _qw);
     }


var _extends = Object.assign ||
function(target) {
    for (var i = 1; i < arguments.length; i++) {
        var source = arguments[i];
        for (var key in source) {
            if (Object.prototype.hasOwnProperty.call(source, key)) {
                target[key] = source[key];
            }
        }
    }
    return target;
};

 

数组解构

let [a, b, c] = [1, 2, 3] // a=1, b=2, c=3

let [i,,j] = [1, 2, 3] // 不连续解构 i=1, j=3

let [k,l] = [1, 2, 3] // 不完全解构 k=1, l=2

let [d, [e], f] = [1, [2], 3] // 嵌套数组解构 d=1, e=2, f=3

let [g, ...h] = [1, 2, 3] // 数组拆分 g=1, h=[2, 3]

对象解构

let {a, b} = {a: 'aaaa', b: 'bbbb'} // a='aaaa' b='bbbb'

let obj = {d: 'aaaa', e: {f: 'bbbb'}}

let {d, e:{f}} = obj // 嵌套解构 d='aaaa' f='bbbb'

let g;

(g = {g: 'aaaa'}) // 以声明变量解构 g='aaaa'

let [h, i, j, k] = 'nice' // 字符串解构 h='n' i='i' j='c' k='e'

 

 

使用场景

变量赋值

我们先来看最基本的使用场景：变量赋值，先来看我们在平时开发中是怎么使用es5对变量赋值的：

var data = {userName: 'aaaa', password: 123456}
var userName = data.userName
var password = data.password
console.log(userName)
console.log(password)
var data1 = ['aaaa', 123456]
var userName1 = data1[0]
var password1 = data1[1]
console.log(userName1)
console.log(password1)

上面两个例子是最简单的例子，用传统es5变量赋值，然后调用，这么写的问题就是显得代码啰嗦，明明一行可以搞定的事情非要用三行代码，来看看解构赋值是怎么干的：

const {userName, password} = {userName: 'aaaa', password: 123456}
console.log(userName)
console.log(password)
const [userName1, password1] = ['aaaa', 123456]
console.log(userName1)
console.log(password1)

相对于es5的语法是不是更加简单明了，在数据量越大用解构赋值的优势越明显

函数参数的定义

一般我们在定义函数的时候，如果函数有多个参数时，在es5语法中函数调用时参数必须一一对应，否则就会出现赋值错误的情况，来看一个例子：

function personInfo(name, age, address, gender) {
  console.log(name, age, address, gender)
}
personInfo('william', 18, 'changsha', 'man')

上面这个例子在对用户信息的时候需要传递四个参数，且需要一一对应，这样就会极易出现参数顺序传错的情况，从而导致bug，接下来来看es6解构赋值是怎么解决这个问题的：

function personInfo({name, age, address, gender}) {
  console.log(name, age, address, gender)
}
personInfo({gender: 'man', address: 'changsha', name: 'william', age: 18})

这么写我们只需要知道要传什么参数就行来，不需要知道参数的顺序也没问题

交换变量的值

在es5中我们需要交换两个变量的值需要借助临时变量的帮助，来看一个例子：

var a=1, b=2, c
c = a
a = b
b = c
console.log(a, b)

来看es6怎么实现：

let a=1, b=2;
[b, a] = [a, b]
console.log(a, b)

是不是比es5的写法更加方便呢

函数的默认参数

在日常开发中，经常会有这种情况：函数的参数需要默认值，如果没有默认值在使用的时候就会报错，来看es5中是怎么做的：

function saveInfo(name, age, address, gender) {
  name = name || 'william'
  age = age || 18
  address = address || 'changsha'
  gender = gender || 'man'
  console.log(name, age, address, gender)
}
saveInfo()

在函数离 main先对参数做一个默认值赋值，然后再使用避免使用的过程中报错，再来看es6中的使用的方法：

function saveInfo({name= 'william', age= 18, address= 'changsha', gender= 'man'} = {}) {
  console.log(name, age, address, gender)
}
saveInfo()

在函数定义的时候就定义了默认参数，这样就免了后面给参数赋值默认值的过程，是不是看起来简单多了.