函数参数

默认参数值

ES2015语法直接实现默认参数值：

function fn(arg = 'foo') {
    console.log(arg)
}

fn()       //=> foo
fn('bar')  //=> bar

默认参数特性还可以用在对象的方法中，而且默认值还是可以是对象的某个属性：

const obj = {
    msg: 'World',
    
    greet(message = this.msg) {
        console.log(`Hello ${message}`)
    }
}

obj.greet()  //=> Hello World
obj.greet('ES2015') //=> Hello ES2015

剩余参数

ES2015之前，我们用arguments这个类数组对象来操作剩余参数，经常会使用Array.slice将arguments转换为一个真正的数组：

function fn() {
    var args = [].slice.call(arguments)

    console.log(args)
    console.log(args.filter(function(i) {
        return i % 2 == 0
    }))
}

fn(1, 2, 3, 4, 5)
//=>
// 1 2 3 4 5
// 2 4

ES2015为Array对象新增了Array.from方法，作用是将一些可以被转换为数组的对象转换为数组，最主要的就是针对arguments：

function fn() {
    console.log(Array.from(arguments))
}

fn(1, 2, 3, 4, 5)  //=> 1 2 3 4 5

使用语法

ES2015对剩余参数有更为优雅的做法，可直接将参数列表转换为一个正常数组，避免了[].slice等不干净的代码：

function fn(foo, ...rest) {
    console.log(`foo: ${foo}`)
    console.log(`Rest Arguments: ${rest.join(',')}`)
}

fn(1, 2, 3, 4 ,5)
//=>
// foo: 1
// Rest Arguments: 2,3,4,5

使用场景：

在ECMAScript开发中，arguments最大的应用场景就是判断当前的调用行为，以及获取未在函数形参内定义的传入参数。比如十分常用的merge和mixin函数就可以使用到剩余参数这个特性：

function merge(target = {}, ...objs) {
    for(const obj of objs) {
        const keys = Object.keys(obj)
        
        for(const key of keys) {
            target[key] = obj[key]
        }
    }
    return target
}

console.log(merge({ a: 1 }, { b: 2 }, { c: 3 }))
//=> { a: 1, b: 2, c: 3 }

解构传参

在ECMAScript对函数的定义中，apply和call可以让开发者以一个自定义的上下文（函数中的this）来传入参数：

function fn() {}
var obj = { foo: 'bar' }

fn.apply(obj, [ 1, 2, 3 ])

fn.call(obj, 1, 2, 3)

但有些时候，函数内部没有对上下文做任何访问，所以apply和call的意义只在于控制传入参数，而上下文则可能会使用null代替：

function sum(...numbers) {
    return numbers.reduce((a, b) => a + b)
}
sun.apply(null, [ 1, 2, 3 ]) //=> 6

然而对于不了解apply或call的开发者来说，这无疑是一种“不干净”的实现。在ES2015中，可以用表达式解构来实现。ES2015的解构传参同样是使用数组作为传入参数，但不同的是，解构传参不会替换函数调用中的上下文。
与剩余参数一样，解构传参使用...作为语法糖提示符：

function sum(...numbers) {
    return numbers.reduce((a, b) => a + b)
}

sum(...[ 1, 2, 3 ]) //=> 6