ES6 学习笔记(6) 函数的扩展

2018-03-07  本文已影响0人  MrZhou_b216

1. 函数的默认值

  function log(x, y = 'world') {
    console.log(x,y)
  }
  log('hello')  // hello world
  log('hello' , 'china')  // hello china
  log('hello' ,'')  // hello

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

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

  // 写法一 函数参数的默认值是空对象，但是设置了对象解构赋值的默认值
  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]

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

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

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

  var x = 1;
  function foo(x, y = function() { x = 2; }) {
    var x = 3;
    y();
    console.log(x);
  }
  
  foo() // 3
  x // 1
  // 如果将var x = 3的var去除，函数foo的内部变量x就指向第一个参数x， 
  // 与匿名函数内部的x是一致的，所以最后输出的就是2，而外层的全局变        
  // 量x依然不受影响。
  var x = 1;
  function foo(x, y = function() { x = 2; }) {
    x = 3;
    y();
    console.log(x);
  }

  foo() // 2
  x // 1

  function throwIfMissing() {
    throw new Error('Missing parameter');
  }

  function foo(mustBeProvided = throwIfMissing()) {
    return mustBeProvided;
  }
  
  foo()
  // Error: Missing parameter

(2) 可以将参数默认值设为undefined，表明这个参数是可以省略的。

  function foo(optional = undefined) { ··· }

2. rest 参数

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

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

1.0 rest 参数之后不能再有其他参数（即只能是最后一个参数），否则会报错。
2.0 函数的length属性，不包括 rest 参数。

3. 严格模式

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

  // 报错
  function doSomething(value = 070) {
    'use strict';
    return value;
  }

两种方法可以规避这种限制。
1.0 第一种是设定全局性的严格模式，这是合法的。
2.0 第二种是把函数包在一个无参数的立即执行函数里面。

4. name 属性

函数的name属性，返回该函数的函数名。

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

5. 箭头函数

  // 正常函数写法
  var result = values.sort(function (a, b) {
    return a - b;
  });

  // 箭头函数写法
  var result = values.sort((a, b) => a - b);

箭头函数有几个使用注意点。
（1）函数体内的this对象，就是定义时所在的对象，而不是使用时所在的对象。
（2）不可以当作构造函数，也就是说，不可以使用new命令，否则会抛出一个错误。
（3）不可以使用arguments对象，该对象在函数体内不存在。如果要用，可以用 rest 参数代替。
（4）不可以使用yield命令，因此箭头函数不能用作 Generator函数。
上面四点中，第一点尤其值得注意。this对象的指向是可变的，但是在箭头函数中，它是固定的。

6. 双冒号运算符

箭头函数可以绑定this对象，大大减少了显式绑定this对象的写法（call、apply、bind）。但是，箭头函数并不适用于所有场合，所以现在有一个提案，提出了“函数绑定”（function bind）运算符，用来取代call、apply、bind调用。

函数绑定运算符是并排的两个冒号（::），双冒号左边是一个对象，右边是一个函数。该运算符会自动将左边的对象，作为上下文环境（即this对象），绑定到右边的函数上面。

7. 尾部调用优化

尾调用（Tail Call）是函数式编程的一个重要概念，本身非常简单，一句话就能说清楚，就是指某个函数的最后一步是调用另一个函数。

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

ES6 的尾调用优化只在严格模式下开启，正常模式是无效的。
这是因为在正常模式下，函数内部有两个变量，可以跟踪函数的调用栈。
func.arguments：返回调用时函数的参数。
func.caller：返回调用当前函数的那个函数。

尾递归优化只在严格模式下生效，那么正常模式下，或者那些不支持该功能的环境中，有没有办法也使用尾递归优化呢？回答是可以的，就是自己实现尾递归优化。

它的原理非常简单。尾递归之所以需要优化，原因是调用栈太多，造成溢出，那么只要减少调用栈，就不会溢出。怎么做可以减少调用栈呢？就是采用“循环”换掉“递归”。

8. 函数参数的尾逗号

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

上一篇 下一篇

猜你喜欢

热点阅读