Разница между обработчиками событий и обратными вызовами

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

обработчик событий-это процедура, вызываемая при возникновении события. Это может быть обратный звонок.

обработчик событий-это тип обратного вызова. Он вызывается всякий раз, когда происходит событие. Термин обычно используется в терминах пользовательских интерфейсов, где события-это такие вещи, как перемещение мыши, щелчок и так далее.

обратный вызов (из Википедии): "исполняемый код, который передается в качестве аргумента другой код".
обработчик событий (снова из Википедии): "асинхронная подпрограмма обратного вызова, которая обрабатывает входные данные, полученные в программе".

Что происходит так, как я всегда это понимал: обработчик событий - это очень специфический тип обратного вызова.

этот вопрос очень старый, но я нашел эту ссылку от MSDN очень интересно. Я надеюсь, что любой, кто наткнется на этот вопрос, получит что-то из этой ссылки.

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

обратный звонок - босс специально попросил сотрудника выполнить задачу, и в конце выполнения задачи Босс хочет получить уведомление. Работник убеждается что когда задание выполнено, он уведомляет только босса о том, что запросил, не нужно всех боссов. Сотрудник не будет уведомлять босса, если частичная работа выполнена. Это будет только после того, как все задачи будут выполнены.Только один босс запросил информацию, и сотрудник отправил ответ только одному боссу.

другой аспект этого заключается в том, что события описывают то, что произошло в прошлом, тогда как обратный вызов часто используется во время чего-то происходит.

когда событие срабатывает, вам говорят, что что-то произошло. Когда используется обратный вызов, вас просят принять участие в чем-то.

библиотека или фреймворк могут выдавать события, которые дают вам знать, что что-то произошло. Фреймворк предлагает вам точки, в которых вы можете подключить код (возможно, как callbacks), так что вы можете принять активное участие в процессе.

часть проблемы заключается в том, что событие, обратный вызов относятся к техническим mcehanisms, а также более абстрактные процессы.

ответ Джеймса Андерсона самый подробный. Расширение его ответа; Обратный вызов относится к любому коду, который передается в качестве аргумента методу, предназначенному для последующего асинхронного вызова. Однако обратный вызов не определяет, как должен быть реализован сам процесс обратного вызова. Здесь начинается классификация обратных вызовов. Традиционно процесс обратного вызова будет выглядеть :

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

var server = require('http').createServer(function(req, res){/* your code */});

на createServer - это определяемая библиотекой функция, которая гарантирует, что процесс обнаружения вызывает правильный обратный вызов, который в этом случае является function(req, res){/* your code */}

• во время выполнения процесс обнаружения получает прямое местоположение обратного вызова (потому что определенная библиотекой функция сделала это за вас) и вызывает он. Это будет означать 2 вещи:
  • разработчикам библиотеки всегда нужно знать, как обращаться с различными процессами обнаружения, поскольку каждый из них может иметь другой способ вызова
  • и если обратный вызов должен быть вызван несколько раз, это может поставить задачу процесса обнаружения. Например, если процесс обнаружения является процессом GUI,то вы хотели бы, чтобы поток GUI работал с как можно меньшим количеством задач, для плавного интерфейса GUI.

таким образом, возникла необходимость в реализации механизма обратного вызова, который решил эти 2 вопроса:

• внешний процесс, который определил бы параллельную точку для библиотечной функции для регистрации обратных вызовов и для процесса обнаружения, чтобы уведомить о том, когда эти зарегистрированные обратные вызовы должны быть вызваны.
  • это означало, что разработчики обоих этих процессов теперь могут работать независимо друг от друга, не зная пути друг друга.
  • этот внешний процесс стал известен как цикл событий (в узле, например). Термин "событие" - это просто процесс уведомления цикла события процессом обнаружения, и зарегистрированный обратный вызов стал известен как обработчик событий.
• внешний процесс (или цикл событий) поставил события в очередь и выполнил их, тем самым сняв нагрузку с процесса обнаружения, который теперь мог возобновиться к тому, что он делал лучший.

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

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

базовые механизмы похожи, но семантика разная. Как обратные вызовы, так и обработчики событий называются асинхронно.

функция обратного вызова обычно передается явно из подпрограммы вызывающего абонента для запроса некоторой информации. Информация возвращается некоторое время спустя, передается в качестве аргументов обратно вызываемому абоненту. В это время процедура вызова завершает свою работу. Часто обратный вызов является замыканием-синтаксически внутри вызов рутины, и часто без имени (анонимный). Это может выглядеть немного похоже на приведенное ниже, в javascript:

function caller() {
    someLibrary.getMeSomething(arg1, arg2, function(returnedData) {
        // this is the callback which will do something with returnedData
    });
}

Итак, вызываемый (someLibrary.getMeSomething) получает анонимную функцию обратного вызова, а через некоторое время эта функция вызывается с помощью returnedData. Обратный вызов - это однократное событие для одного получателя.

обработчики событий также "вызываются", но обычно они используются в течение длительного периода для нескольких событий, таких как щелчки мыши, сеть событий и т. д. Кроме того, несколько объектов могут быть заинтересованы в одном и том же событии. По этим причинам вы обычно "подписываетесь" или "регистрируетесь" на события в коде установки (например, инициализация объекта), а обработчик событий обычно является именованным методом. Обычно также каждый тип события определяется как константа или строка.

поэтому в Python это может выглядеть так:

class MyUIClass:

    def __init__(self):
        someUILib.register(someUILib.events.MOUSE_CLICK, self.my_mouse_click_handler);

    def my_mouse_click_handler(self, eventInfo):
        # do something with event
        if eventInfo.x < 100:
             print 'You clicked in the margin'

Мне нравится, как все эти ответы отличаются друг от друга.

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

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

обработчик событий-это функция (метод), вызываемая при возникновении события. Это может быть обратный звонок.

обработчик событий вызывается из системы.