我认为延续是回调的一种特殊情况。一个函数可以回调任意数量的函数,任意次数。例如:
var array = [1, 2, 3];
forEach(array, function (element, array, index) {
array[index] = 2 * element;
});
console.log(array);
function forEach(array, callback) {
var length = array.length;
for (var i = 0; i < length; i++)
callback(array[i], array, i);
}
但是,如果一个函数将另一个函数作为最后一个回调,则第二个函数称为第一个函数的延续。例如:
var array = [1, 2, 3];
forEach(array, function (element, array, index) {
array[index] = 2 * element;
});
console.log(array);
function forEach(array, callback) {
var length = array.length;
// This is the last thing forEach does
// cont is a continuation of forEach
cont(0);
function cont(index) {
if (index < length) {
callback(array[index], array, index);
// This is the last thing cont does
// cont is a continuation of itself
cont(++index);
}
}
}
如果一个函数最后执行另一个函数,则称为尾调用。有些语言(例如Scheme)会执行尾部调用优化。这意味着尾部调用不会产生函数调用的全部开销。而是将其实现为简单的goto(将调用函数的堆栈框架替换为tail调用的堆栈框架)。
奖励:继续传球。考虑以下程序:
console.log(pythagoras(3, 4));
function pythagoras(x, y) {
return x * x + y * y;
}
现在,如果每个操作(包括加法,乘法等)都以函数的形式编写,那么我们将有:
console.log(pythagoras(3, 4));
function pythagoras(x, y) {
return add(square(x), square(y));
}
function square(x) {
return multiply(x, x);
}
function multiply(x, y) {
return x * y;
}
function add(x, y) {
return x + y;
}
另外,如果不允许我们返回任何值,那么我们将不得不使用以下延续:
pythagoras(3, 4, console.log);
function pythagoras(x, y, cont) {
square(x, function (x_squared) {
square(y, function (y_squared) {
add(x_squared, y_squared, cont);
});
});
}
function square(x, cont) {
multiply(x, x, cont);
}
function multiply(x, y, cont) {
cont(x * y);
}
function add(x, y, cont) {
cont(x + y);
}
这种不允许您返回值(因此您必须求助于传递延续)的编程方式称为延续传递方式。
但是,延续传递样式存在两个问题:
- 传递连续性会增加调用堆栈的大小。除非您使用诸如Scheme这样的语言来消除尾部调用,否则您将冒用尽堆栈空间的风险。
- 编写嵌套函数很痛苦。
通过异步调用延续,可以在JavaScript中轻松解决第一个问题。通过异步调用延续,函数将在调用延续之前返回。因此,调用堆栈的大小不会增加:
Function.prototype.async = async;
pythagoras.async(3, 4, console.log);
function pythagoras(x, y, cont) {
square.async(x, function (x_squared) {
square.async(y, function (y_squared) {
add.async(x_squared, y_squared, cont);
});
});
}
function square(x, cont) {
multiply.async(x, x, cont);
}
function multiply(x, y, cont) {
cont.async(x * y);
}
function add(x, y, cont) {
cont.async(x + y);
}
function async() {
setTimeout.bind(null, this, 0).apply(null, arguments);
}
第二个问题通常使用称为的函数解决,该函数call-with-current-continuation
通常缩写为callcc
。不幸的是callcc
,不能完全用JavaScript实现,但是我们可以为大多数用例编写一个替换函数:
pythagoras(3, 4, console.log);
function pythagoras(x, y, cont) {
var x_squared = callcc(square.bind(null, x));
var y_squared = callcc(square.bind(null, y));
add(x_squared, y_squared, cont);
}
function square(x, cont) {
multiply(x, x, cont);
}
function multiply(x, y, cont) {
cont(x * y);
}
function add(x, y, cont) {
cont(x + y);
}
function callcc(f) {
var cc = function (x) {
cc = x;
};
f(cc);
return cc;
}
该callcc
函数接受一个函数f
并将其应用于current-continuation
(缩写为cc
)。该current-continuation
是延续函数调用后包起来的函数体的其余部分callcc
。
考虑一下函数的主体pythagoras
:
var x_squared = callcc(square.bind(null, x));
var y_squared = callcc(square.bind(null, y));
add(x_squared, y_squared, cont);
所述current-continuation
第二的callcc
是:
function cc(y_squared) {
add(x_squared, y_squared, cont);
}
同样current-continuation
,第一个callcc
是:
function cc(x_squared) {
var y_squared = callcc(square.bind(null, y));
add(x_squared, y_squared, cont);
}
由于current-continuation
第一个的callcc
包含另一个,callcc
因此必须将其转换为延续传递样式:
function cc(x_squared) {
square(y, function cc(y_squared) {
add(x_squared, y_squared, cont);
});
}
因此,从本质callcc
上讲,将整个函数体从逻辑上转换回我们的起点(并为这些匿名函数命名cc
)。使用callcc的此实现的pythagoras函数将变为:
function pythagoras(x, y, cont) {
callcc(function(cc) {
square(x, function (x_squared) {
square(y, function (y_squared) {
add(x_squared, y_squared, cont);
});
});
});
}
同样,您不能callcc
在JavaScript中实现,但是可以在JavaScript中实现延续传递样式,如下所示:
Function.prototype.async = async;
pythagoras.async(3, 4, console.log);
function pythagoras(x, y, cont) {
callcc.async(square.bind(null, x), function cc(x_squared) {
callcc.async(square.bind(null, y), function cc(y_squared) {
add.async(x_squared, y_squared, cont);
});
});
}
function square(x, cont) {
multiply.async(x, x, cont);
}
function multiply(x, y, cont) {
cont.async(x * y);
}
function add(x, y, cont) {
cont.async(x + y);
}
function async() {
setTimeout.bind(null, this, 0).apply(null, arguments);
}
function callcc(f, cc) {
f.async(cc);
}
该功能callcc
可用于实现复杂的控制流结构,例如try-catch块,协程,生成器,光纤等。