Непрозрачное определение
Функция обратного вызова - это функция, которую вы предоставляете другому фрагменту кода, что позволяет ему вызываться этим кодом.
Придуманный пример
Зачем тебе это делать? Допустим, есть служба, которую нужно вызвать. Если сервис возвращается сразу, вы просто:
- Назови это
- Ждать результата
- Продолжайте, как только появится результат
Например, предположим, что служба была factorialфункцией. Когда вы хотите получить значение 5!, вы вызываете его factorial(5)и выполняете следующие шаги:
Ваше текущее местоположение выполнения сохранено (в стеке, но это не важно)
Исполнение передано factorial
Когда factorialзавершается, он помещает результат туда, куда вы можете добраться до него
Казнь возвращается туда, где она была в [1]
Теперь предположим, что это factorialзаняло очень много времени, потому что вы даете ему огромные цифры, и он должен работать на каком-то суперкомпьютерном кластере. Допустим, вы ожидаете, что для возврата результата потребуется 5 минут. Вы могли бы:
Сохраняйте свой дизайн и запускайте программу ночью, когда вы спите, чтобы не смотреть на экран половину времени
Разработайте свою программу, чтобы делать другие вещи, пока factorialона делает свое дело
Если вы выберете второй вариант, обратные вызовы могут работать на вас.
Сквозной дизайн
Чтобы использовать шаблон обратного вызова, вам нужно иметь возможность вызывать factorialследующим образом:
factorial(really_big_number, what_to_do_with_the_result)
Второй параметр, what_to_do_with_the_resultэто функция, которую вы отправляете factorial, в надежде, что factorialвызовет ее в результате перед возвратом.
Да, это означает, что это factorialдолжно быть написано для поддержки обратных вызовов.
Теперь предположим, что вы хотите иметь возможность передать параметр в ваш обратный вызов. Теперь вы не можете, потому что вы не собираетесь это называть, factorialэто так. Поэтому factorialнеобходимо написать, чтобы вы могли передать свои параметры, и он просто передаст их вашему обратному вызову, когда вызовет его. Это может выглядеть так:
factorial (number, callback, params)
{
result = number! // i can make up operators in my pseudocode
callback (result, params)
}
Теперь, когда factorialэто разрешено, ваш обратный вызов может выглядеть так:
logIt (number, logger)
{
logger.log(number)
}
и ваш призыв к factorialбудет
factorial(42, logIt, logger)
Что если вы хотите что-то вернуть logIt? Ну, ты не можешь, потому что factorialне обращает на это внимания.
Ну, почему нельзя factorialпросто вернуть то, что возвращает ваш обратный вызов?
Сделать это неблокирующим
Поскольку выполнение предназначено для передачи factorialобратному вызову после его завершения, оно действительно не должно ничего возвращать вызывающей стороне. И в идеале, он каким-то образом запустит свою работу в другом потоке / процессе / машине и сразу же вернется, чтобы вы могли продолжить, возможно, что-то вроде этого:
factorial(param_1, param_2, ...)
{
new factorial_worker_task(param_1, param_2, ...);
return;
}
Теперь это «асинхронный вызов», что означает, что когда вы вызываете его, он немедленно возвращается, но еще не выполнил свою работу. Таким образом, вам нужны механизмы, чтобы проверить его и получить его результат, когда он будет завершен, и ваша программа стала более сложной в этом процессе.
И, кстати, используя этот шаблон, вы factorial_worker_taskможете запустить ваш обратный вызов асинхронно и немедленно вернуться.
Ну так что ты делаешь?
Ответ заключается в том, чтобы оставаться в рамках модели обратного вызова. Всякий раз, когда вы хотите написать
a = f()
g(a)
и fдолжен вызываться асинхронно, вместо этого вы будете писать
f(g)
где gпередается в качестве обратного вызова.
Это в корне меняет топологию потока вашей программы и требует некоторого привыкания.
Ваш язык программирования может очень вам помочь, предоставляя вам возможность создавать функции на лету. В приведенном выше коде функция gможет быть такой же маленькой, как и print (2*a+1). Если ваш язык требует, чтобы вы определили это как отдельную функцию с совершенно ненужным именем и подписью, то ваша жизнь станет неприятной, если вы будете часто использовать этот шаблон.
Если, с другой стороны, ваш язык позволяет вам создавать лямбды, то вы в гораздо лучшей форме. Затем вы в конечном итоге написать что-то вроде
f( func(a) { print(2*a+1); })
что намного приятнее
Как пройти обратный звонок
Как бы вы передали функцию обратного вызова factorial? Ну, вы могли бы сделать это несколькими способами.
Если вызываемая функция выполняется в том же процессе, вы можете передать указатель на функцию
Или, может быть, вы хотите сохранить словарь fn name --> fn ptrв вашей программе, в этом случае вы можете передать имя
Возможно, ваш язык позволяет вам определять функцию на месте, возможно, как лямбда! Внутренне это создает какой-то объект и передает указатель, но вам не нужно об этом беспокоиться.
Возможно, вызываемая вами функция выполняется на совершенно отдельной машине, и вы вызываете ее, используя сетевой протокол, такой как HTTP. Вы можете представить свой обратный вызов как функцию, вызываемую по HTTP, и передать ее URL.
Вы поняли идею.
Недавний рост обратных вызовов
В эту эру Интернета, в которую мы вступили, службы, к которым мы обращаемся, часто находятся в сети. Мы часто не имеем никакого контроля над этими службами, то есть мы не писали их, мы не поддерживаем их, мы не можем гарантировать, что они работают или как они работают.
Но мы не можем ожидать, что наши программы будут блокироваться, пока мы ожидаем ответа этих служб. Осознавая это, поставщики услуг часто разрабатывают API, используя шаблон обратного вызова.
JavaScript очень хорошо поддерживает обратные вызовы, например, с лямбдами и замыканиями. И в мире JavaScript много активности, как в браузере, так и на сервере. Есть даже платформы JavaScript, разрабатываемые для мобильных устройств.
По мере продвижения вперед все больше и больше людей будут писать асинхронный код, для которого это понимание будет необходимо.
