В чем разница между продолжением и обратным вызовом?

я считаю, что продолжения являются частным случаем обратных вызовов. Функция может вызывать любое количество функций, любое количество раз. Например:

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 (с кадром стека вызывающей функции, замененным кадром стека хвостового вызова).

бонус: переходим к продолжению прохождения стиля. Рассмотрим следующую программу:

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

этот стиль программирования, в котором вам не разрешено возвращать значения (и, следовательно, вы должны прибегать к передаче продолжений вокруг) называется продолжением передачи стиль.

однако есть две проблемы с продолжением прохождения стиля:

1. передача продолжений увеличивает размер стека вызовов. Если вы не используете язык, подобный схеме, которая исключает хвостовые вызовы, вы рискуете исчерпать пространство стека.
2. это боль, чтобы написать вложенные функции.

первая проблема может быть легко решена в 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);

The 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, становится тогда:

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, сопрограммы, генераторы,волокнами и т. д.