后续传递(continuation)和回调(callback)的差别

时间:2021-1-8 作者:admin

前言

在绝大多数的编程语言中,函数通常返回值给调用它的对象。举个例子:

var sum = add(2, 3);
console.log(sum);
function add(x, y) {
    return x + y;
}

然而,在现在很多的“函数是一等公民”的语言(函数式编程语言)中,我们也可以把值返回给回调函数,而不是直接返回给调用的那个对象。

add(2, 3, function (sum) {
    console.log(sum);
});
function add(x, y, cont) {
    cont(x + y);
}

上面的例子可以看出,我们并没有把参数运行后的值返回,而是将它传递给了cont,而cont也就是调用时的那个函数。我们称cont是add的一个传递。

相信大家对回调非常熟悉吧,对于后续传递风格,或许只是喜欢函数式编程的小伙伴可能了解过。那么回调与后续传递的差别是什么呢?

中语

我认为后续传递是回调的一种特殊的形式。一个函数可以有许多个回调函数,许多次回调:

var array = [1, 2, 3];
forEach(array, function (element, array, index) {
    array[index] = 2 * element;
});
function forEach(array, callback) {
    var length = array.length;
    for (var i = 0; i < length; i++)
        callback(array[i], array, i);
}

当一个函数做的最后一件事情是回调另一个函数的时候,我们称第二个函数为第一个函数的后续传递。e.g:

var array = [1, 2, 3];
forEach(array, function (element, array, index) {
    array[index] = 2 * element;
});
function forEach(array, callback) {
    var length = array.length;
    // last thing forEach does
    // cont is a continuation of forEach
    cont(0);
    function cont(index) {
        if (index < length) {
            callback(array[index], array, index);
            // last thing cont does
            // cont is a continuation of itself
            cont(++index);
        }
    }
}

如果当一个函数的最后一件是是调用另一个函数的时候,我们称这种情况叫做尾调用(参考尾递归#2 )。一些解释器,比如Scheme语言的解释器会对尾调用进行优化。这样不会导致函数的堆积(比如斐波那契的运算),而将状态层层传递。

后话

如果想继续了解后续传递风格请往下读

alert(pythagoras(3, 4));
function pythagoras(x, y) {
    return x * x + y * y;
}

如果我们将每一种运算,包括加减乘除都写成函数的形式(在函数式编程中,运算符就是函数)。

alert(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, alert);
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);
}

(面目狰狞,仿佛又看到了node的魔鬼金字塔)

不允许返回任何值,所以你不得不吧这些值或者状态传到下一个函数里面。这种风格叫做后续传递风格(continuation passing style)。
不过仍然存在两个问题需要考虑。

这种风格明显增加了调用栈的大小需求,如果你没有用Scheme或者支持尾调用优化的语言去写代码,很容易就会栈溢出(我也不知道容易不容易。。。)
魔鬼金字塔。
当然,第一个问题其实是好解决的,因为js支持异步编程。异步调用的结果就是,当你调用传递函数的时候,前面的状态已经计算好了。这样就导致堆栈大小并不会增加。

Function.prototype.async = async;
pythagoras.async(3, 4, alert);
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() {
    //use js setTimeout to implement async
    setTimeout.bind(null, this, 0).apply(null, arguments);
}

解决第二个问题的方法通常是利用一个函数callcc,全称是call-with-current-continuation,可惜的是callcc并没有在js里完整的实现。所以我们重写一下

pythagoras(3, 4, alert);
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;
}
声明:本文内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎进行举报,并提供相关证据,工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。