ES6之函数的扩展

前端布道人

于 2024-05-17 00:00:00 发布

阅读量1k

点赞数 30

文章标签： es6 前端 javascript

本文链接：https://blog.csdn.net/BradenHan/article/details/138889754

版权

1. ES6之函数的扩展
2. 总结

1. ES6之函数的扩展

1.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

上面代码检查函数 log 的参数 y 有没有赋值，如果没有，则指定默认值为 World 。

这种写法的缺点在于，如果参数 y 赋值了，但是对应的布尔值为 false ，则该赋值不起作用。

就像上面代码的最后一行，参数 y 等于空字符，结果被改为默认值。

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

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

log('Hello') // Hello World
log('Hello','China') // Hello China
log('Hello','') // Hello

1.1.1. 注意事项

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

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

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

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

1.1.1.3. 参数默认值是惰性求值的。

参数默认值不是传值的，而是每次都重新计算默认值表达式的值。

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.1.2. 与解构赋值默认值结合使用

参数默认值可以与解构赋值的默认值，结合起来使用。

function foo({x, y = 5} = {}) {
  console.log(x, y);
}

foo() // undefined 5

双重默认值

function fetch(url, 
{ 
  body = ''
  , method = 'GET'
  , headers
  = {} 
} = {}) {
  console.log(method);
}

fetch('http://example.com')
// "GET"

1.2. 函数的 length 属性

指定了默认值以后，函数的 length 属性，将返回没有指定默认值的参数个数。

也就是说，指定了默认值后， length 属性将失真。

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

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

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

1.3. rest 参数

ES6 引入 rest 参数（形式为 …变量名），用于获取函数的多余参数，这样就不需要使用 arguments 对象了。

rest 参数搭配的变量是一个数组，该变量将多余的参数放入数组中。

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

上面代码的 add 函数是一个求和函数，利用 rest 参数，可以向该函数传入任意数目的参数。

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)

1.3.1. 注意事项

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

1.4. 严格模式

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

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

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
  }
};

1.5. 箭头函数

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

var f = v => v;

上面的箭头函数等同于：

var f = function(v) {
  return v;
};

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

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


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