函数的扩展

函数的扩展

1.函数参数的默认值

基本用法

ES6允许为函数参数设置默认值，直接写在参数定义后面。

function log(x,y='World'){ console.log(x,y); } log('Hello') // Hello World log('Hello', 'China') // Hello China log('Hello', '') // Hello

此方法除了简洁，有两个好处。一是，方便阅读代码，不用看函数体，意识到哪些参数可以省略。二是，有利于优化代码，即使拿掉参数，也不会导致代码无法运行。 函数参数变量是默认声明的，不能用let或const再次声明。函数不能有同名参数。参数默认值不是传值，每次都重新计算表达式的值。

function foo(x=5){ let x = 1; //error const x = 2; //error } //不报错 function foo(x,x,y){ //... } //报错 function foo(x,x,y=1){ //... } log('Hello') // Hello World log('Hello', 'China') // Hello China log('Hello', '') // Hello

与解构赋值默认值结合使用

有两种情况，一是对象解构赋值默认值，二是函数参数的默认值。

function fetch(url, { body = '', method = 'GET', headers = {} } = {}) { console.log(method); } fetch('http://example.com') // "GET"

函数fetch没有第二个参数时，函数参数的默认值就会生效，然后才是解构赋值的默认值生效，变量method才会取到默认值GET，出现了双重默认值。 练习：

// 写法一 function m1({x = 0, y = 0} = {}) { return [x, y]; } // 写法二 function m2({x, y} = { x: 0, y: 0 }) { return [x, y]; }

上面两种写法都对函数的参数设定了默认值，区别是写法一函数参数的默认值是空对象，但是设置了对象解构赋值(x,y)的默认值；写法二函数参数的默认值是一个有具体属性的对象，但是没有设置对象解构赋值(x,y)的默认值。

// 函数没有参数的情况 m1() // [0, 0] m2() // [0, 0] // x 和 y 都有值的情况 m1({x: 3, y: 8}) // [3, 8] m2({x: 3, y: 8}) // [3, 8] // x 有值，y 无值的情况 m1({x: 3}) // [3, 0] m2({x: 3}) // [3, undefined] // x 和 y 都无值的情况 m1({}) // [0, 0]; m2({}) // [undefined, undefined] m1({z: 3}) // [0, 0] m2({z: 3}) // [undefined, undefined]

参数默认值的位置

一般情况下，定义了默认值的参数应该在尾部，因为赋值时容易看出省略哪个参数，如果在非尾部，无法省略，除非显示的输入undefined，null没有这个效果。

function f(x, y = 5, z) { return [x, y, z]; } f() // [undefined, 5, undefined] f(1) // [1, 5, undefined] f(1, ,2) // 报错 f(1, undefined, 2) // [1, 5, 2]

函数的length属性

指定默认值后，length属性返回没有指定默认值的参数个数。该属性的含义是该函数预期传入的参数的个数，指定默认值后就不包括这个参数。如果设置了默认值的参数不是尾参数，那么length属性不计入后面的参数。

(function (a) {}).length // 1 (function (a = 5) {}).length // 0 (function (a, b, c = 5) {}).length // 2 (function (a = 0, b, c) {}).length // 0 (function (a, b = 1, c) {}).length // 1

作用域

设置参数的默认值后，参数会形成一个单独的作用域，等到初始化结束，作用域消失。 例1：

var x = 1; function f(x, y = x) { console.log(y); } f(2) // 2 let x = 1; function f(y = x) { //相当于let y=x let x = 2; console.log(y); } f() // 1 如果没有let x = 1;会报错

例2：

var x = 1; function foo(x, y = function() { x = 2; }) { var x = 3; y(); console.log(x); } foo() // 3 x // 1 var x = 1; function foo(x, y = function() { x = 2; }) { x = 3; y(); console.log(x); } foo() // 2 x // 1

上面代码中，函数foo的参数形成一个单独的作用域，声明了变量x和y，y的默认值是一个匿名函数，内部变量x指向第一个参数x。函数foo内部又声明了一个内部变量x，该变量与第一个参数x不在一个作用域，执行y后内部变量和全局变量x的值都没变。去掉var后，函数foo的内部变量x就指向第一个参数x，但全局变量依然不受影响。

应用

利用参数默认值，可以指定某一个参数不得省略，如果省略就抛出一个错误。也可以将参数默认值设为undefined，表明可省略。

function throwIfMissing() { //不可省略 throw new Error('Missing parameter'); } function foo(mustBeProvided = throwIfMissing()) { return mustBeProvided; } foo() //如果无参数，就会调用默认值 throwIfMissing函数，抛出错误 // Error: Missing parameter function foo(optional = undefined) { ··· } //可省略

2.rest函数

形式为…变量名，用于获取函数多余的参数，rest参数搭配的变量是一个数组，将多余的参数放入数组中。rest参数之后不能再有其他参数，否则报错，不包括length属性。

function push(array, ...items) { items.forEach(function(item) { array.push(item); console.log(item); }); } var a = []; push(a, 1, 2, 3)

3.严格模式

ES2016中规定只要函数参数使用了默认值、解构赋值、或扩展运算符，那么函数内部就不能显式的设定为严格模式，否则报错。因为函数内部的严格模式同时适用于函数体和函数参数，但参数先于函数体执行。有两种方法可以规避这种限制，第一种是设定全局性严格模式，二是把函数包在一个无参数的立即执行函数里面。

1. 'use strict'; function doSomething(a, b = a) { // code } 2. const doSomething = (function () { 'use strict'; return function(value = 42) { return value; }; }());

4.name属性

函数name属性，返回该函数的函数名。如果将一个匿名函数赋给一个变量，name属性也会返回实际函数名。Function构造函数返回的函数实例，name属性的值为anonymous。bind返回的函数，name属性值会加上bound前缀。

(new Function).name //"anonymous" function foo() {}; foo.bind({}).name //"bound foo" (function(){}).bind({}).name //"bound"

5.箭头函数

基本用法

ES6允许使用“箭头”定义函数。如果箭头函数不需要参数或多个参数，就使用圆括号代替参数部分。如果代码块部分多于一条语句，就要用大括号将他们括起来，并用return语句返回。如果返回一个对象，必须在对象外面加上括号，否则会报错。

var f=v=>v; //等同于 var f=function (v){ return v; };

箭头函数可以使表达式更简洁

const full = ({ first, last }) => first + ' ' + last; // 等同于 function full(person) { return person.first + ' ' + person.last; } const numbers = (...nums) => nums; numbers(1, 2, 3, 4, 5) // [1,2,3,4,5] const headAndTail = (head, ...tail) => [head, tail]; headAndTail(1, 2, 3, 4, 5) // [1,[2,3,4,5]]

使用注意

（1）函数体内的this对象，就是定义时所在的对象，而不是使用时所在的对象。 （2）不可以当作构造函数，也就是说，不可以使用new命令，否则会抛出一个错误。 （3）不可以使用arguments对象，该对象在函数体内不存在。如果要用，可以用 rest 参数代替。 （4）不可以使用yield命令，因此箭头函数不能用作 Generator 函数。

不适用场合

因为箭头函数使this从“动态”变成“静态”，所以有两种情况下，不能使用箭头函数。 （1）定义对象的方法，且该方法内部包括this。 （2）需要动态this的时候，也不应使用箭头函数。

箭头函数的嵌套

箭头函数内允许嵌套，可能可读性存在问题，可以采用下面的写法。

const plus1 = a => a + 1; const mult2 = a => a * 2; mult2(plus1(5)) // 12

6.尾调用优化（某个函数的最后一步是调用另一个函数）

注意：这几种情况不属于尾调用

// 情况一 function f(x){ let y = g(x); return y; } // 情况二 function f(x){ return g(x) + 1; } // 情况三 function f(x){ g(x); } //情况三同下 function f(x){ g(x); return undefined; }

尾调用优化（只保留内层函数的调用帧）

只有不再用到外层函数的内部变量，内层函数的调用帧才会取代外层函数的调用帧，否则就无法进行“尾调用优化”。

function addOne(a){ var one = 1; function inner(b){ return b + one; } return inner(a); }

尾递归

函数调用自身，称为递归。如果尾调用自身，就称为尾递归。防止“栈溢出”和超时。

function factorial(n) { if (n === 1) return 1; return n * factorial(n - 1); } factorial(5) // 120

上面的代码计算n的阶乘，复杂度 O(n)。 如果改成尾递归，复杂度O（1）。

递归函数的改写

（1）在尾递归函数之外，再提供一个正常形式的函数。

function tailFactorial(n, total) { if (n === 1) return total; return tailFactorial(n - 1, n * total); } function factorial(n) { return tailFactorial(n, 1); } factorial(5) // 120

（2）采用ES6默认值

function factorial(n, total = 1) { if (n === 1) return total; return factorial(n - 1, n * total); } factorial(5) // 120

7.函数参数的尾逗号

允许函数的最后一个参数有尾逗号。

8.Function.prototype.toString()

明确要求返回一模一样的原始代码

function /* foo comment */ foo () {} foo.toString() // "function /* foo comment */ foo () {}"

9.catch 命令的参数省略

try { // ... } catch { // ... }

允许省略参数