文章目录
函数的扩展
函数参数的默认值
基本用法
ES6之前,不能直接指定,需要变通。
function log(x, y) {
y = y || 'World'
console.log(x, y)
}
log('Hello', '');
这种写法的缺点在于如果y
赋值了,但对应布尔值为false
,则赋值不起作用。就像上面代码中,y
为空字符,结果被改为默认值。
为了避免这个问题,通常需要先判断y
是否被赋值,如果没有,再等于默认值。
if (typeof y === 'undefined') {
y = 'World';
}
ES6允许设置默认值。
function log(x, y = 'World') {
console.log(x, y);
}
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) {
// ...
}
// SyntaxError: Duplicate parameter name not allowed in this context
- 参数默认值不是传值的,而是每次重新重新计算,即惰性求值。
let x = 99;
function foo(p = x + 1) {
console.log(p);
}
foo() // 100
x=100
foo() // 101
与解构赋值默认值结合使用
function foo({x, y = 5}) {
console.log(x, y);
}
foo({}) // undefined 5
foo() // TypeError: Cannot read property 'x' of undefined
foo({x: 1}) // 1 5
上面代码只使用了对象解构赋值,因此foo
调用没提供参数时,x
和y
就不会生成,从而报错,通过函数参数的默认值可以避免这种情况。
function foo({x, y = 5} = {}) {
console.log(x, y);
}
foo() // undefined 5
上面代码指定,如果没有提供参数,函数foo的参数默认为一个空对象。(个人ps:从结果(undefined 5)来看,默认并非空对象,而是具有默认值的对象。)
作为练习,请问下面两种写法有什么差别?
// 写法一
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]
m1({x = 1}); // [1, 0]
m2({x = 1}); // [1, undefined]
m1({}) // [0, 0];
m2({}) // [undefined, undefined]
参数默认值的位置
定义默认值的参数应是尾参数,如果是非尾部的参数设置默认值,实际上这个参数无法省略。
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]
f(1, null, 2) // [1, null, 2]
函数的length属性
length
属性的含义是:该函数预期传入的参数个数。
指定默认值后,预期传入的参数个数就不包括这个参数了,函数的length
属性将返回没有指定默认值的参数个数,length
属性将失真。
如果设置了默认值的参数不是尾参数,那么length
属性也不再计入后面的参数了。
(function (a, b, c = 5) {}).length // 2
(function (a, b = 1, c) {}).length // 1
同理,后文的rest参数也不会计入length
属性。
(function(...args) {}).length // 0
作用域(需理解)
一旦设置了参数的默认值,函数进行声明初始化时,参数会形成一个单独的作用域(context)。等到初始化结束,这个作用域就会消失。这种语法行为,在不设置参数默认值时,是不会出现的。
var x = 1;
function f(x, y = x) {
console.log(y);
}
f(2) // 2
let x = 1;
function f(y = x) {
let x = 2;
console.log(y);
}
f() // 1
var x = 1;
function foo(x = x) {
// ...
}
foo() // ReferenceError: Cannot access 'x' before initialization
如果参数的默认值是一个函数,该函数的作用域也遵守这个规则。请看下面的例子。
let foo = 'outer';
function bar(func = () => foo) {
let foo = 'inner';
console.log(func());
}
bar(); // outer
function bar(func = () => foo) {
let foo = 'inner';
console.log(func());
}
bar() // ReferenceError: foo is not defined
下面是一个更复杂的例子。
var x = 1;
function foo(x, y = function() { x = 2; }) {
var x = 3;
y();
console.log(x);
}
foo() // 3
x // 1
上面代码中,函数foo
的参数形成一个作用域。这个作用域里面,声明了变量x
、变量y
,y
的默认值是一个匿名函数。这个匿名函数内部的变量x,指向同一个作用域的第一个参数x
。
函数foo
的内部又声明了一个内部变量x,它与第一个参数x
不是同一个作用域,所以不是同一个变量,因此执行y
后,内部变量x
和外部全局变量x
的值都没变。
如果将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
另外,可以将参数默认值设为undefined,表明这个参数是可以省略的。
function foo(optional = undefined) { ··· }
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
// arguments变量的写法
function sortNumbers() {
return Array.prototype.slice.call(arguments).sort();
}
// rest参数的写法
const sortNumbers = (...numbers) => numbers.sort();
arguments
对象不是数组,而是一个类似数组的对象。所以为了使用数组的方法,必须使用Array.prototype.slice.call
先将其转为数组。rest 参数就不存在这个问题,它就是一个真正的数组,数组特有的方法都可以使用。
rest
参数之后不能再有其他参数(即只能是最后一个参数),否则会报错。
// 报错
function f(a, ...b, c) {
// ...
}
函数的length
属性,不包括 rest
参数。
(function(a) {}).length // 1
(function(...a) {}).length // 0
严格模式
从ES5开始,函数内部可以设定为严格模式。
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
}
};
这样规定的原因是,函数内部的严格模式,同时适用函数体和函数参数。但函数执行的时候,先执行函数参数,再执行函数体。这样就有不合理的地方,只有从函数体中才能知道参数是否以严格模式执行,但是参数却先于函数体执行。
// 报错
function doSomething(value = 070) {
'use strict';
return value;
}
上面代码中,参数value的默认值是八进制数070,但是严格模式下不能用前缀0表示八进制,所以应该报错。但是实际上,JavaScript 引擎会先成功执行value = 070,然后进入函数体内部,发现需要用严格模式执行,这时才会报错。
因此,标准索性禁止了这种用法,只要参数使用了默认值、解构赋值、或者扩展运算符,就不能显式指定严格模式。
两种方法可以规避这种限制。第一种是设定全局性的严格模式,这是合法的。
'use strict';
function doSomething(a, b = a) {
// code
}
第二种是把函数包在一个无参数的立即执行函数里面。
const doSomething = (function () {
'use strict';
return function(value = 42) {
return value;
};
}());
name属性
函数的name属性,返回该函数的函数名。
function foo() {}
foo.name // "foo"
这个属性早就被浏览器广泛支持,但直到ES6才写入标准。
需要注意的是,ES6 对这个属性的行为做出了一些修改。如果将一个匿名函数赋值给一个变量,ES5 的name
属性,会返回空字符串,而 ES6 的name
属性会返回实际的函数名。
var f = function () {};
// ES5
f.name // ""
// ES6
f.name // "f"
如果将一个具名函数赋值给一个变量,则 ES5 和 ES6 的name
属性都返回这个具名函数原本的名字。
const bar = function baz() {};
// ES5
bar.name // "baz"
// ES6
bar.name // "baz"
Function
构造函数返回的函数实例,name属性的值为anonymous
。
(new Function).name // "anonymous"
bind返回的函数,name
属性值会加上bound
前缀。
function foo() {};
foo.bind({}).name // "bound foo"
(function(){}).bind({}).name // "bound "
箭头函数
基本用法
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;
};
如果箭头函数代码块多于一条语句,就要用大括号,并且使用return
语句返回。
如果箭头函数直接返回一个对象,则必须在对象外加上括号,否则会报错。
var sum = (num1, num2) => { return num1 + num2; }
// 报错
let getTempItem = id => { id: id, name: "Temp" };
// 不报错
let getTempItem = id => ({ id: id, name: "Temp" });
let foo = () => { a: 1 };
foo() // undefined
最后一种情况虽然可以运行但会得到错误结果。引擎认为大括号是代码块,所以执行了一行语句a: 1
。此时a
可以被解释为语句的标签,因此实际执行语句是1
,然后函数就结束了,没有返回值。
箭头函数用处:
- 可以与变量解构结合使用
const full = ({ first, last }) => first + ' ' + last;
- 使表达更加简洁
const isEven = n => n % 2 === 0;
const square = n => n * n;
- 简化回调函数
[1,2,3].map(x => x * x);
- 与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]]
使用注意点(待记忆)
- 箭头函数没有自己的
this
对象(内部的this
是定义时上层作用域中的this
) - 不可以当作构造函数,即不可以对它使用
new
命令,否则会抛出错误。 - 不可以使用
arguments
对象,该对象在函数体内不存在。如果要用,可以用rest
参数代替。 - 不可以使用
yield
命令,因此箭头函数不能用作Generator函数。
function foo() {
setTimeout(() => {
console.log('id:', this.id);
}, 100);
}
var id = 21;
foo.call({ id: 42 });
// id: 42
上面代码中,this
指向函数定义生效时所在的对象({id:42}
)。
function Timer() {
this.s1 = 0;
this.s2 = 0;
// 箭头函数
setInterval(() => this.s1++, 1000);
// 普通函数
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
上面代码中,Timer
函数内部设置了两个定时器,箭头函数的this
绑定定义时所在的作用域(即Timer
函数),普通函数的this
指向运行时所在的作用域(即全局对象)。所以,3100ms后,timer.s1
更新了三次,而timer.s2
一次都没更细更新。
箭头函数实际上可以让this
指向固定化,绑定this
使得它不再可变,这种特性很有利于封装回调函数。下面是一个例子,DOM 事件的回调函数封装在一个对象里面。
var handler = {
id: '123456',
init: function() {
document.addEventListener('click',
event => this.doSomething(event.type), false);
},
doSomething: function(type) {
console.log('Handling ' + type + ' for ' + this.id);
}
};
上面代码的init()
方法中,使用了箭头函数,因此里面的this
,总是指向handler对象。如果回调函数是普通函数,那么运行this.doSomething()
这一行会报错,因为此时this
指向document对象。
下面是 Babel 转箭头函数产生的 ES5 代码,就能清楚地说明this
的指向。
// ES6
function foo() {
setTimeout(() => {
console.log('id:', this.id);
}, 100);
}
// ES5
function 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);
};
};
};
}
var f = foo.call({id: 1});
var t1 = f.call({id: 2})()(); // id: 1
var t2 = f().call({id: 3})(); // id: 1
var t3 = f()().call({id: 4}); // id: 1
答案:this
的指向只有一个,就是函数foo
的this
,因为所有的内层函数都是箭头函数,都没有自己的this
,都指向最外层foo
函数的this
。如果这个例子的所有内层函数都写成普通函数,那么每个函数的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
从“动态”变成“静态”,下面两个场合不应该用箭头函数。
- 定义对象的方法,且该方法内部包括
this
。
const cat = {
lives: 9,
jumps: () => {
this.lives--;
}
}
上面代码中,cat.jumps()
方法是一个箭头函数,这是错误的。调用cat.jumps()
时,如果是普通函数,该方法内部的this
指向cat
;如果写成上面那样的箭头函数,使得this
指向全局对象,因此不会得到预期结果。这是因为对象不构成单独的作用域,导致jumps
箭头函数定义时的作用域就是全局作用域。
再看一个例子。
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
就会动态指向被点击的按钮对象。
另外,如果函数体很复杂,有许多行,或者函数内部有大量的读写操作,不单纯是为了计算值,这时也不应该使用箭头函数,而是要使用普通函数,这样可以提高代码可读性。
嵌套的箭头函数(待理解)
箭头函数内部还可以再使用箭头函数。
下面时一个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]
将上面的函数改用箭头函数书写。
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]
下面是一个部署管道机制(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
下面是改写λ 演算的例子。
// λ演算的写法
fix = λf.(λx.f(λv.x(x)(v)))(λx.f(λv.x(x)(v)))
// ES6的写法
var fix = f => (x => f(v => x(x)(v)))
(x => f(v => x(x)(v)));
上面两种写法,几乎是一一对应的。由于 λ 演算对于计算机科学非常重要,这使得我们可以用 ES6 作为替代工具,探索计算机科学。
尾调用优化
什么是尾调用?
尾调用:指某个函数的最后一步是调用另一个函数。
function f(x){
return g(x);
}
一下三种情况都不属于尾调用。
// 情况一
function f(x){
let y = g(x);
return y;
} // 调用后有赋值操作
// 情况二
function f(x){
return g(x) + 1;
} // 调用后有计算操作
// 情况三
function f(x){
g(x);
} // 等同于返回了undefined
尾调用优化
尾调用之所以与其它调用不同,就在于它的特殊的调用位置。
函数调用会在内存形成一个“调用记录”,又称“调用帧”(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();
// 等同于
function f() {
return g(3);
}
f();
// 等同于
g(3);
上面代码中,如果函数g
不是尾调用,函数f
就需要保存m
和n
的值、g
的调用位置等信息。但因为调用g
后,f
就结束了,所以完全可以删除f(x)
的调用帧,只保留g(3)
的调用帧。
这就叫做“尾调用优化”,即只保留内层函数的调用帧,如果所有函数都是尾调用,那么完全可以做到每次执行时,调用帧只有一项,这将大大节省内存。
注意,只有不再用到外层函数的内部变量,内层函数的调用帧才会取代外层函数的调用帧,否则就无法进行“尾调用优化”。
注意,目前只有Safari支持尾调用优化,Chrome和Firefox都不支持。
尾递归
尾递归:尾调用自身。
递归非常耗费内存,很容易发生“栈溢出”错误。但对于尾递归来说,由于只存在一个调用帧,所以永远不会发生“栈溢出”错误。
function factorial(n) {
if (n === 1) return 1;
return n * factorial(n - 1);
}
factorial(5) // 120
上面代码是一个阶乘函数,最多需要保存n
个调用记录,复杂度O(n)。
改用尾递归,则只保留一个调用记录,复杂度O(1)。
function factorial(n, total) {
if (n === 1) return total;
return factorial(n - 1, n * total);
}
factorial(5, 1) // 120
还有一个比较著名的例子,就是计算Fibonacci数列,也能充分说明尾递归优化的重要性。
非尾递归的Fibonacci数列实现如下。
function Fibonacci (n) {
if ( n <= 1 ) {return 1};
return Fibonacci(n - 1) + Fibonacci(n - 2);
}
Fibonacci(10) // 89
Fibonacci(100) // 超时
Fibonacci(500) // 超时
尾递归优化过的Dibonacci数列实现如下:
function Fibonacci2 (n , ac1 = 1 , ac2 = 1) {
if( n <= 1 ) {return ac2};
return Fibonacci2 (n - 1, ac2, ac1 + ac2);
}
Fibonacci2(100) // 573147844013817200000
Fibonacci2(1000) // 7.0330367711422765e+208
Fibonacci2(10000) // Infinity
由此可见,”尾调用优化“对递归操作意义重大,所以一些函数式编程语言将其写入了语言规格。ES6亦是如此,第一次明确规定,所有ECMAScript的实现,都必须部署”尾调用优化“。这也就是说。ES6中只要使用尾递归,就不会发生栈溢出(超时),相对节省内存。
递归函数的改写
改写方法:把所有用到的内部变量改写成函数的参数。比如上面阶乘的例子,但这样的缺点就是不太直观,第一眼很难看出来,为什么计算5
的阶乘,需要传入两个参数5
和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
,看起来就正常多了。
或者使用柯里化,将多参数的函数转换为单参数的形式。
function currying(fn, n) {
return function (m) {
return fn.call(this, m, n);
};
}
function tailFactorial(n, total) {
if (n === 1) return total;
return tailFactorial(n - 1, n * total);
}
const factorial = currying(tailFactorial, 1);
factorial(5) // 120
- 采用 ES6 的函数默认值。
function factorial(n, total = 1) {
if (n === 1) return total;
return factorial(n - 1, n * total);
}
factorial(5) // 120
总结:递归本质就是一种循环操作,纯粹得函数式编程语言没有循环操作命令,所有得循环都用递归实现,这就是为什么尾递归对这些语言极其重要。对于其他支持“尾调用优化”的语言(比如 Lua,ES6),只需要知道循环可以用递归代替,而一旦使用递归,就最好使用尾递归。
严格模式
ES6得尾调用优化只在严格模式下开启,正常模式是无效的。
这是因为在正常模式下,函数内部有两个变量,可以跟踪函数的调用栈。
- func.arguments:返回调用时函数的参数。
- func.caller:返回调用当前函数的那个函数。
- 尾调用优化发生时,函数的调用栈就会改写,因此上面两个变量就会失真。严格模式禁用这两个变量,所以尾调用模式仅在严格模式下生效。
function restricted() {
'use strict';
restricted.caller; // 报错
restricted.arguments; // 报错
}
restricted();
尾递归优化的实现(待理解)
尾递归优化只在严格模式下生效,那么正常模式下,或在不支持该功能的环境中,也有办法使用尾递归优化。
原理:尾递归之所以需要优化,原因是调用栈太多,造成溢出,那么只要减少调用栈就不会溢出。如何减少?采用”循环“换掉”递归“。
下面是一个正常的递归函数。
function sum(x, y) {
if (y > 0) {
return sum(x + 1, y - 1);
} else {
return x;
}
}
sum(1, 100000)
// Uncaught RangeError: Maximum call stack size exceeded(…)
上面代码中,sum
是一个递归函数,参数x
是需要累加的值,参数y
控制递归次数。一旦递归100000次,就会报错,提示超出调用栈的最大次数。
蹦床函数(trampoline)可以将递归执行转为循环执行。
function trampoline(f) {
while (f && f instanceof Function) {
f = f();
}
return f;
}
上面就是蹦床函数的一个实现,它接受一个函数f
作为参数。只要f
执行后返回一个函数,然后执行该函数,而不是函数里面调用函数,这样就避免了递归执行,从而就消除了调用栈过大的问题。
然后要坐的就是将原来的递归函数,改写为每一步返回一个函数。
function sum(x, y) {
if (y > 0) {
return sum.bind(null, x + 1, y - 1);
} else {
return x;
}
}
上面代码中,sum
的每次执行,都会返回自身的另一个版本。
现在使用蹦床函数执行sum
就不会发生栈溢出。
trampoline(sum(1, 100000))
// 100001
蹦床函数并不是真正的尾递归优化,下面的实现才是。
function tco(f) {
var value;
var active = false;
var accumulated = [];
return function accumulator() {
accumulated.push(arguments);
if (!active) {
active = true;
while (accumulated.length) {
value = f.apply(this, accumulated.shift());
}
active = false;
return value;
}
};
}
var sum = tco(function(x, y) {
if (y > 0) {
return sum(x + 1, y - 1)
}
else {
return x
}
});
sum(1, 100000)
// 100001
上面代码中,tco
函数是尾递归优化的实现,它的奥妙就在于状态变量active
。默认情况下,这个变量是不激活的。一旦进入尾递归优化的过程,这个变量就激活了。然后,每一轮递归sum
返回的都是undefined
,所以就避免了递归执行;而accumulated
数组存放每一轮sum
执行的参数,总是有值的,这就保证了accumulator
函数内部的while
循环总是会执行。这样就很巧妙地将“递归”改成了“循环”,而后一轮的参数会取代前一轮的参数,保证了调用栈只有一层。
函数参数的尾逗号
ES2017允许函数的最后一个参数有尾逗号。
此前,函数定义和调用时,都不允许最后一个参数后面出现逗号。
function clownsEverywhere(
param1,
param2
) { /* ... */ }
上面代码中,如果在param2
后面加一个逗号,就会报错。
但是如果以后想添加参数或调用次序时,就势必要在原来最后一个参数后面添加一个逗号,这对版本管理系统来说会显示添加逗号那一行也发生了变动,这看上去有点冗余。因此新的语法允许定义和调用时,尾部直接有一个逗号。
function clownsEverywhere(
param1,
param2,
) { /* ... */ }
Function.prototype.toString()
ES2019对函数实例的toString()
方法做出了修改。
toString
方法返回函数代码本身,以前会省略注释和空格。修改后的toString()
方法,明确要求返回一模一样的原始代码。
function /* foo comment */ foo () {}
foo.toString()
// function foo() {}
//修改后
foo.toString()
// "function /* foo comment */ foo () {}"
catch命令的参数省略
JavaScript的try...catch
结构以前明确要求cathc
后面必须跟参数,接受try
代码块抛出的错误对象。(哪怕可能用不到这个参数)
ES2019允许catch
语句省略参数。
try {
// ...
} catch (err) {
// 处理错误
}
//ES2019
try {
// ...
} catch {
// ...
}