函数的扩展

函数的扩展

函数参数的默认值

基本用法

1. ES6 之前，不能直接为函数的参数指定默认值，只能采用变通的方法

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

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

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

3. ES6 的写法还有两个好处：首先，阅读代码的人，可以立刻意识到哪些参数是可以省略的，不用查看函数体或文档；其次，有利于将来的代码优化，即使未来的版本在对外接口中，彻底拿掉这个参数，也不会导致以前的代码无法运行

   function Point(x = 0, y = 0) {
     this.x = x;
     this.y = y;
   }
   const p = new Point();
   p // { x: 0, y: 0 }
   

4. 参数变量是默认声明的，所以不能用let或const再次声明

   function foo(x = 5) {
     let x = 1; // error
     const x = 2; // error
   }
   

5. 使用参数默认值时，函数不能有同名参数

   // 不报错
   function foo(x, x, y) {
     // ...
   }
   
   // 报错
   function foo(x, x, y = 1) {
     // ...
   }
   // SyntaxError: Duplicate parameter name not allowed in this context
   

6. 另外，一个容易忽略的地方是，参数默认值不是传值的，而是每次都重新计算默认值表达式的值。也就是说，参数默认值是惰性求值的

   let x = 99;
   function foo(p = x + 1) {
     console.log(p);
   }
   foo() // 100
   
   x = 100;
   foo() // 101	参数p的默认值是x + 1。这时，每次调用函数foo，都会重新计算x + 1，而不是默认p等于 100
   

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

1. 参数默认值可以与解构赋值的默认值，结合起来使用(没有使用函数参数的默认值)

   function foo({x, y = 5}) {	//这个函数的参数是一个对象，但是没有一个默认值
     console.log(x, y);
   }
   //只有当函数foo的参数是一个对象时，变量x和y才会通过解构赋值生成
   foo({}) // undefined 5
   foo({x: 1}) // 1 5
   foo({x: 1, y: 2}) // 1 2
   //如果函数foo调用时没提供参数，变量x和y就不会生成，从而报错
   foo() // TypeError: Cannot read property 'x' of undefined
   

2. 使用函数参数的默认值

   function foo({x, y = 5} = {}) {	//这个空对象作为函数参数的默认值
     console.log(x, y);
   }
   foo() // undefined 5
   

3. 另一个解构赋值默认值的例子

   //这种写法不能省略第二个参数，如果结合函数参数的默认值，就可以省略第二个参数function fetch(url, { body = '', method = 'GET', headers = {} }) {  console.log(method);}fetch('http://example.com', {})	// "GET"fetch('http://example.com')		// 报错//函数fetch没有第二个参数时，函数参数的默认值就会生效，然后才是解构赋值的默认值生效function fetch(url, { body = '', method = 'GET', headers = {} } = {}) {  console.log(method);}fetch('http://example.com')	// "GET"
   

4. 解构赋值写法区别

   // 写法一:函数参数的默认值是空对象，但是设置了对象解构赋值的默认值function m1({x = 0, y = 0} = {}) {  return [x, y];}// 写法二:函数参数的默认值是一个有具体属性的对象，但是没有设置对象解构赋值的默认值function m2({x, y} = { x: 0, y: 0 }) {  return [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]
   

参数默认值的位置

1. 通常情况下，定义了默认值的参数，应该是函数的尾参数。因为这样比较容易看出来，到底省略了哪些参数。如果非尾部的参数设置默认值，实际上这个参数是没法省略的

   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]
   

   这时，无法只省略该参数，而不省略它后面的参数，除非显式输入undefined

2. 如果传入undefined，将触发该参数等于默认值，null则没有这个效果

   function foo(x = 5, y = 6) {  console.log(x, y);	//x参数对应undefined，结果触发了默认值}						//y参数等于null，就没有触发默认值foo(undefined, null)// 5 null
   

函数的length属性

1. 指定了默认值以后，函数的length属性，将返回没有指定默认值的参数个数。也就是说，指定了默认值后，length属性将失真

   length属性的返回值，等于函数的参数个数减去指定了默认值的参数个数

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

2. 这是因为length属性的含义是，该函数预期传入的参数个数。某个参数指定默认值以后，预期传入的参数个数就不包括这个参数了。后文的 rest 参数也不会计入length属性

   (function(...args) {}).length // 0
   

3. 如果设置了默认值的参数不是尾参数，那么length属性也不再计入后面的参数了

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

作用域

1. 一旦设置了参数的默认值，函数进行声明初始化时，参数会形成一个单独的作用域（context）。等到初始化结束，这个作用域就会消失。这种语法行为，在不设置参数默认值时，是不会出现的

   var x = 1;function f(x, y = x) {  console.log(y);}f(2) // 2	调用函数f时，参数形成一个单独的作用域，在这个作用域里面，默认值变量x指向第一个参数x，而不是全局变量x，所以输出是2
   

2. 如果1中没有传值给x

   let x = 1;function f(y = x) {  let x = 2;  console.log(y);}f() // 1	函数f调用时，参数y = x形成一个单独的作用域，这个作用域里面，变量x本身没有定义，所以指向外层的全局变量x。函数调用时，函数体内部的局部变量x影响不到默认值变量x
   

3. 如果2中没有定义x，全局变量x不存在，就会报错

   function f(y = x) {  let x = 2;  console.log(y);}f() // ReferenceError: x is not defined
   

4. 进一步修改代码

   var x = 1;function foo(x = x) {  // ...}foo() // ReferenceError: x is not defined//参数x = x形成一个单独作用域。实际执行的是let x = x，由于暂时性死区的原因，这行代码会报错”x 未定义“
   

5. 如果参数的默认值是一个函数，该函数的作用域也遵守这个规则

   let foo = 'outer';//函数bar的参数func的默认值是一个匿名函数，返回值为变量foofunction bar(func = () => foo) {	  let foo = 'inner';  console.log(func());}bar(); // outer//函数参数形成的单独作用域里面，并没有定义变量foo，所以foo指向外层的全局变量foo，因此输出outer
   

6. 如果5中没有定义foo

   function bar(func = () => foo) {  let foo = 'inner';  console.log(func());}bar() // ReferenceError: foo is not defined//匿名函数里面的foo指向函数外层，但是函数外层并没有声明变量foo，所以就报错了
   

rest参数

1. ES6 引入 rest 参数（形式为...变量名），用于获取函数的多余参数，这样就不需要使用arguments对象了。rest 参数搭配的变量是一个数组，该变量将多余的参数放入数组中

   function add(...values) {  let sum = 0;  for (var val of values) {    sum += val;  }  return sum;}add(2, 5, 3) // 10
   

2. 下面是一个 rest 参数代替arguments变量的例子

   // arguments变量的写法function sortNumbers() {  return Array.prototype.slice.call(arguments).sort();}// rest参数的写法const sortNumbers = (...numbers) => numbers.sort();
   

3. arguments对象不是数组，而是一个类似数组的对象。所以为了使用数组的方法，必须使用Array.prototype.slice.call先将其转为数组。rest 参数就不存在这个问题，它就是一个真正的数组，数组特有的方法都可以使用。下面是一个利用 rest 参数改写数组push方法的例子

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

4. rest 参数之后不能再有其他参数（即只能是最后一个参数），否则会报错

   function f(a, ...b, c) {  // ...}	//报错
   

5. 函数的length属性，不包括 rest 参数

   (function(a) {}).length  // 1(function(...a) {}).length  // 0(function(a, ...b) {}).length  // 1
   

严格模式

1. 从 ES5 开始，函数内部可以设定为严格模式

   function doSomething(a, b) {  'use strict';  // code}
   

2. ES2016 做了一点修改，规定只要函数参数使用了默认值、解构赋值、或者扩展运算符，那么函数内部就不能显式设定为严格模式，否则会报错

   // 报错，默认值function doSomething(a, b = a) {  'use strict';  // code}// 报错，解构赋值const doSomething = function ({a, b}) {  'use strict';  // code};// 报错，扩展运算符const doSomething = (...a) => {  'use strict';  // code};const obj = {  // 报错，解构赋值  doSomething({a, b}) {    'use strict';    // code  }};
   

3. 这样规定的原因是，函数内部的严格模式，同时适用于函数体和函数参数。但是，函数执行的时候，先执行函数参数，然后再执行函数体。这样就有一个不合理的地方，只有从函数体之中，才能知道参数是否应该以严格模式执行，但是参数却应该先于函数体执行

   // 报错//参数value的默认值是八进制数070，但是严格模式下不能用前缀0表示八进制，所以应该报错function doSomething(value = 070) {  'use strict';  return value;}	
   

4. 虽然可以先解析函数体代码，再执行参数代码，但是这样无疑就增加了复杂性。因此，标准索性禁止了这种用法，只要参数使用了默认值、解构赋值、或者扩展运算符，就不能显式指定严格模式，两种方法可以规避这种限制

   1. 第一种是设定全局性的严格模式，这是合法的

      'use strict';function doSomething(a, b = a) {  // code}
      

   2. 第二种是把函数包在一个无参数的立即执行函数里面

      const doSomething = (function () {  'use strict';  return function(value = 42) {    return value;  };}());
      

name 属性

1. 函数的name属性，返回该函数的函数名

   function foo() {}foo.name // "foo"
   

2. 需要注意的是，ES6 对这个属性的行为做出了一些修改。如果将一个匿名函数赋值给一个变量，ES5 的name属性，会返回空字符串，而 ES6 的name属性会返回实际的函数名

   var f = function () {};// ES5f.name // ""// ES6f.name // "f"
   

3. 如果将一个具名函数赋值给一个变量，则 ES5 和 ES6 的name属性都返回这个具名函数原本的名字

   const bar = function baz() {};// ES5bar.name // "baz"// ES6bar.name // "baz"
   

4. Function构造函数返回的函数实例，name属性的值为anonymous

   (new Function).name // "anonymous"
   

5. bind返回的函数，name属性值会加上bound前缀

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

   bind()方法主要就是将函数绑定到某个对象，bind()会创建一个函数，函数体内的this对象的值会被绑定到传入bind()中的第一个参数的值，例如：f.bind(obj)，实际上可以理解为obj.f()，这时f函数体内的this自然指向的是obj

箭头函数

基本用法

1. ES6 允许使用“箭头”（=>）定义函数

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

2. 如果箭头函数不需要参数或需要多个参数，就使用一个圆括号代表参数部分

   var f = () => 5;// 等同于var f = function () { return 5 };var sum = (num1, num2) => num1 + num2;// 等同于var sum = function(num1, num2) {  return num1 + num2;};
   

3. 如果箭头函数的代码块部分多于一条语句，就要使用大括号将它们括起来，并且使用return语句返回

   var sum = (num1, num2) => { return num1 + num2; }
   

4. 由于大括号被解释为代码块，所以如果箭头函数直接返回一个对象，必须在对象外面加上括号，否则会报错

   let getTempItem = id => { id: id, name: "Temp" };// 报错let getTempItem = id => ({ id: id, name: "Temp" });// 不报错
   

5. 下面是一种特殊情况，虽然可以运行，但会得到错误的结果

   let foo = () => { a: 1 };foo() // undefined//a可以被解释为语句的标签，因此实际执行的语句是1;，然后函数就结束了，没有返回值
   

6. 如果箭头函数只有一行语句，且不需要返回值，就不用写大括号了

7. 箭头函数可以与变量解构结合使用

   const full = ({ first, last }) => first + ' ' + last;// 等同于function full(person) {  return person.first + ' ' + person.last;}
   

8. 箭头函数使得表达更加简洁

   const isEven = n => n % 2 === 0;const square = n => n * n;
   

9. 箭头函数的一个用处是简化回调函数

   // 普通函数写法[1,2,3].map(function (x) {  return x * x;});// 箭头函数写法[1,2,3].map(x => x * x);
   

10. rest 参数与箭头函数结合

    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指向函数运行时所在的对象，但是这一点对箭头函数不成立。它没有自己的this对象，内部的this就是定义时上层作用域中的this。也就是说，箭头函数内部的this指向是固定的，相比之下，普通函数的this指向是可变的

function foo() {setTimeout(() => { console.log('id:', this.id);}, 100);}var id = 21;foo.call({ id: 42 });// id: 42//如果是普通函数，执行时this应该指向全局对象window，这时应该输出21//箭头函数导致this总是指向函数定义生效时所在的对象（本例是{id: 42}），所以打印出来的是42

• 下面例子是回调函数分别为箭头函数和普通函数，对比它们内部的this指向

function Timer() {this.s1 = 0;this.s2 = 0;// 箭头函数	前者的this绑定定义时所在的作用域（即Timer函数）setInterval(() => this.s1++, 1000);// 普通函数	后者的this指向运行时所在的作用域（即全局对象）setInterval(function () { this.s2++;}, 1000);}var timer = new Timer();setTimeout(() => console.log('s1: ', timer.s1), 3100);setTimeout(() => console.log('s2: ', timer.s2), 3100);// s1: 3// s2: 0

• 箭头函数实际上可以让this指向固定化，绑定this使得它不再可变，这种特性很有利于封装回调函数。下面是一个例子，DOM 事件的回调函数封装在一个对象里面

var handler = {id: '123456',init: function() { document.addEventListener('click',   event => this.doSomething(event.type), false);},	//使用了箭头函数，这导致这个箭头函数里面的this，总是指向handler对象doSomething: function(type) { console.log('Handling ' + type  + ' for ' + this.id);}};//如果回调函数是普通函数，那么运行this.doSomething()这一行会报错，因为此时this指向document对象

• 总之：箭头函数根本没有自己的this，导致内部的this就是外层代码块的this。正是因为它没有this，所以也就不能用作构造函数

• 下面是 Babel 转箭头函数产生的 ES5 代码，就能清楚地说明this的指向

  // ES6function foo() {  setTimeout(() => {    console.log('id:', this.id);  }, 100);}// ES5function foo() {  var _this = this;  setTimeout(function () {    console.log('id:', _this.id);  }, 100);}//上面代码中，转换后的 ES5 版本清楚地说明了，箭头函数里面根本没有自己的this，而是引用外层的this
  

• 下面的代码之中，this的指向有几个？

  function foo() {  return () => {    return () => {      return () => {        console.log('id:', this.id);      };    };  };}//call调用的时候会执行一次函数var f = foo.call({id: 1});var t1 = f.call({id: 2})()(); // id: 1var t2 = f().call({id: 3})(); // id: 1var t3 = f()().call({id: 4}); // id: 1
  

  答案是this的指向只有一个，就是函数foo的this，这是因为所有的内层函数都是箭头函数，都没有自己的this，它们的this其实都是最外层foo函数的this。所以不管怎么嵌套，t1、t2、t3都输出同样的结果。如果这个例子的所有内层函数都写成普通函数，那么每个函数的this都指向运行时所在的不同对象

• 除了this，以下三个变量在箭头函数之中也是不存在的，指向外层函数的对应变量：arguments、super、new.target

  function foo() {  setTimeout(() => {    console.log('args:', arguments);  }, 100);}foo(2, 4, 6, 8)// args: [2, 4, 6, 8]
  

  上面代码中，箭头函数内部的变量arguments，其实是函数foo的arguments变量

• 由于箭头函数没有自己的this，所以当然也就不能用call()、apply()、bind()这些方法去改变this的指向

  (function() {  return [    (() => this.x).bind({ x: 'inner' })()  ];}).call({ x: 'outer' });// ['outer'] 
  

  上面代码中，箭头函数没有自己的this，所以bind方法无效，内部的this指向外部的this

不适合场合

由于箭头函数使得this从“动态”变成“静态”，下面两个场合不应该使用箭头函数

1. 第一个场合是定义对象的方法，且该方法内部包括this

   globalThis.s = 21;const obj = {  s: 42,  m: () => console.log(this.s)};obj.m() // 21
   

   上面例子中，obj.m()使用箭头函数定义。JavaScript 引擎的处理方法是，先在全局空间生成这个箭头函数，然后赋值给obj.m，这导致箭头函数内部的this指向全局对象，所以obj.m()输出的是全局空间的21，而不是对象内部的42。上面的代码实际上等同于下面的代码

   globalThis.s = 21;globalThis.m = () => console.log(this.s);const obj = {  s: 42,  m: globalThis.m};obj.m() // 21
   

   由于上面这个原因，对象的属性建议使用传统的写法定义，不要用箭头函数定义

2. 第二个场合是需要动态this的时候，也不应使用箭头函数

   var button = document.getElementById('press');button.addEventListener('click', () => {  this.classList.toggle('on');});
   

   上面代码运行时，点击按钮会报错，因为button的监听函数是一个箭头函数，导致里面的this就是全局对象。如果改成普通函数，this就会动态指向被点击的按钮对象

另外，如果函数体很复杂，有许多行，或者函数内部有大量的读写操作，不单纯是为了计算值，这时也不应该使用箭头函数，而是要使用普通函数，这样可以提高代码可读性

嵌套的箭头函数

1. 箭头函数内部，还可以再使用箭头函数。下面是一个 ES5 语法的多重嵌套函数

   function insert(value) {  return {into: function (array) {    return {after: function (afterValue) {      array.splice(array.indexOf(afterValue) + 1, 0, value);      return array;    }};  }};}insert(2).into([1, 3]).after(1); //[1, 2, 3]
   

2. 上面这个函数，可以使用箭头函数改写

   let insert = (value) => ({into: (array) => ({after: (afterValue) => {  array.splice(array.indexOf(afterValue) + 1, 0, value);  return array;}})});insert(2).into([1, 3]).after(1); //[1, 2, 3]
   

3. 部署管道机制（pipeline），即前一个函数的输出是后一个函数的输入

   const pipeline = (...funcs) =>  val => funcs.reduce((a, b) => b(a), val);const plus1 = a => a + 1;const mult2 = a => a * 2;const addThenMult = pipeline(plus1, mult2);addThenMult(5)// 12
   

   //可读性较好const plus1 = a => a + 1;const mult2 = a => a * 2;mult2(plus1(5))// 12
   

尾调用优化

什么是尾调用

尾调用（Tail Call）是函数式编程的一个重要概念，就是指某个函数的最后一步是调用另一个函数

function f(x){
  return g(x);	//函数f的最后一步是调用函数g，这就叫尾调用
}

以下三种情况不属于尾调用

// 情况一
function f(x){
  let y = g(x);
  return y;	//调用函数g之后，还有赋值操作，所以不属于尾调用
}

// 情况二
function f(x){
  return g(x) + 1;	//属于调用后还有操作，即使写在一行内
}

// 情况三
function f(x){
  g(x);	
  //相当于最后加了return undefined;
}

尾调用不一定出现在函数尾部，只要是最后一步操作即可

function f(x) {
  if (x > 0) {
    return m(x)
  }
  return n(x);
}
//上面代码中，函数m和n都属于尾调用，因为它们都是函数f的最后一步操作。

尾调用优化（了解）

尾调用之所以与其他调用不同，就在于它的特殊的调用位置

函数调用会在内存形成一个“调用记录”，又称“调用帧”（call frame），保存调用位置和内部变量等信息。如果在函数A的内部调用函数B，那么在A的调用帧上方，还会形成一个B的调用帧。等到B运行结束，将结果返回到A，B的调用帧才会消失。如果函数B内部还调用函数C，那就还有一个C的调用帧，以此类推。所有的调用帧，就形成一个“调用栈”（call stack）

尾调用由于是函数的最后一步操作，所以不需要保留外层函数的调用帧，因为调用位置、内部变量等信息都不会再用到了，只要直接用内层函数的调用帧，取代外层函数的调用帧就可以了

function f() {
  let m = 1;
  let n = 2;
  return g(m + n);
}
f();
//如果函数g不是尾调用，函数f就需要保存内部变量m和n的值、g的调用位置等信息

// 等同于
function f() {
  return g(3);
}
f();

//但由于调用g之后，函数f就结束了，所以执行到最后一步，完全可以删除f(x)的调用帧，只保留g(3)的调用帧

// 等同于
g(3);

这就叫做“尾调用优化”（Tail call optimization），即只保留内层函数的调用帧。如果所有函数都是尾调用，那么完全可以做到每次执行时，调用帧只有一项，这将大大节省内存。这就是“尾调用优化”的意义

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

注意，目前只有 Safari 浏览器支持尾调用优化，Chrome 和 Firefox 都不支持

尾递归

1. 函数调用自身，称为递归。如果尾调用自身，就称为尾递归

2. 递归非常耗费内存，因为需要同时保存成千上百个调用帧，很容易发生“栈溢出”错误（stack overflow）。但对于尾递归来说，由于只存在一个调用帧，所以永远不会发生“栈溢出”错误

   function factorial(n) {
     if (n === 1) return 1;
     return n * factorial(n - 1);
   }
   factorial(5) // 120
   //计算n的阶乘，最多需要保存n个调用记录，复杂度 O(n) 
   

3. 上述代码如果改写成尾递归，只保留一个调用记录，复杂度 O(1)

   function factorial(n, total) {
     if (n === 1) return total;
     return factorial(n - 1, n * total);	//只需保存上一次的计算结果
   }
   
   factorial(5, 1) // 120
   

递归函数的改写

尾递归的实现，往往需要改写递归函数，确保最后一步只调用自身。做到这一点的方法，就是把所有用到的内部变量改写成函数的参数。比如上面的例子，阶乘函数 factorial 需要用到一个中间变量total，那就把这个中间变量改写成函数的参数。这样做的缺点就是不太直观，第一眼很难看出来，为什么计算5的阶乘，需要传入两个参数5和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
   //上面代码通过一个正常形式的阶乘函数factorial，调用尾递归函数tailFactorial，看起来就正常多了
   

2. 采用 ES6 的函数默认值

   function factorial(n, total = 1) {
     if (n === 1) return total;
     return factorial(n - 1, n * total);
   }
   factorial(5) // 120
   //上面代码中，参数total有默认值1，所以调用时不用提供这个值
   

尾调用优化

1. ES6 的尾调用优化只在严格模式下开启，正常模式是无效的

2. 这是因为在正常模式下，函数内部有两个变量，可以跟踪函数的调用栈

   func.arguments：返回调用时函数的参数

   func.caller：返回调用当前函数的那个函数

3. 尾调用优化发生时，函数的调用栈会改写，因此上面两个变量就会失真。严格模式禁用这两个变量，所以尾调用模式仅在严格模式下生效

尾调用优化的实现

函数参数的尾逗号

1. ES2017 允许函数的最后一个参数有尾逗号（trailing comma）

2. 此前，函数定义和调用时，都不允许最后一个参数后面出现逗号

   function clownsEverywhere(
     param1,
     param2
   ) { /* ... */ }
   
   clownsEverywhere(
     'foo',
     'bar'
   );
   //上面代码中，如果在param2或bar后面加一个逗号，就会报错。
   

3. 如果像上面这样，将参数写成多行（即每个参数占据一行），以后修改代码的时候，想为函数clownsEverywhere添加第三个参数，或者调整参数的次序，就势必要在原来最后一个参数后面添加一个逗号。这对于版本管理系统来说，就会显示添加逗号的那一行也发生了变动。这看上去有点冗余，因此新的语法允许定义和调用时，尾部直接有一个逗号

   function clownsEverywhere(
     param1,
     param2,
   ) { /* ... */ }
   
   clownsEverywhere(
     'foo',
     'bar',
   );
   

4. 这样的规定也使得，函数参数与数组和对象的尾逗号规则，保持一致了

Function.prototype.toString()

1. ES2019 对函数实例的toString()方法做出了修改

2. toString()方法返回函数代码本身，以前会省略注释和空格

   function /* foo comment */ foo () {}
   foo.toString()
   // function foo() {}
   //上面代码中，函数foo的原始代码包含注释，函数名foo和圆括号之间有空格，但是toString()方法都把它们省略了
   

3. 修改后的toString()方法，明确要求返回一模一样的原始代码

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

catch 命令的参数省略

1. JavaScript 语言的try...catch结构，以前明确要求catch命令后面必须跟参数，接受try代码块抛出的错误对象

   try {
     // ...
   } catch (err) {
     // 处理错误
   }
   //上面代码中，catch命令后面带有参数err
   

2. 很多时候，catch代码块可能用不到这个参数。但是，为了保证语法正确，还是必须写。ES2019 做出了改变，允许catch语句省略参数

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