What is the difference between hook and callback?

The terminology here is a bit fuzzy. In general the two attempt to achieve similar results.

In general, a callback is a function (or delegate) that you register with the API to be called at the appropriate time in the flow of processing (e.g to notify you that the processing is at a certain stage)

A hook traditionally means something a bit more general that serves the purpose of modifying calls to the API (e.g. modify the passed parameters, monitor the called functions). In this meaning it is usually much lower level than what can be achieved by higher-level languages like Java.

In the context of iOS, the word hook means the exact same thing as callback above


The two term are very similar and are sometimes used interchangably. A hook is an option in a library were the user code can link a function to change the behavior of the library. The library function need not run concurrent with the user code; as in a destructor.

A callback is a specific type of hook where the user code is going to initiate the library call, usually an I/O call or GUI call, which gives contol over to the kernel or GUI subsystem. The controlling process then 'calls back' the user code on an interupt or signal so the user code can supply the handler.

Historically, I've seen hook used for interupt handlers and callback used for GUI event handlers. I also see hook used when the routine is to be static linked and callback used in dynamic code.


Let me chime in with a Javascript answer. In Javascript, callbacks, hooks and events are all used. In this order, they are each higher level concepts than the other.

Unfortunately, they are often used improperly which leads to confusion.

Callbacks

From a control flow perspective, a callback is a function, usually given as an argument, that you execute before returning from your function.

This is usually used in asynchoronous situations when you need to wait for I/O (e.g. HTTP request, a file read, a database query etc.). You don't want to wait with a synchronous while loop, so other functions can be executed in the meantime.

When you get your data, you (permanently) relinquish control and call the callback with the result.

function myFunc(someArg, callback) {
    // ...
    callback(error, result);
}

Because the callback function may be some code that hasn't been executed yet, and you don't know what's above your function in the call stack, generally instead of throwing errors you pass on the error to the callback as an argument. There are error-first and result-first callback conventions.

Mostly callbacks have been replaced by Promises in the Javascript world and since ES2017+, you can natively use async/await to get rid of callback-rich spaghetti code and make asynchronous control flow look like it was synchronous.

Sometimes, in special cascading control flows you run callbacks in the middle of the function. E.g. in Koa (web server) middleware or Redux middleware you run next() which returns after all the other middlewares in the stack have been run.

Hooks

Hooks are not really a well-defined term, but in Javascript practice, you provide hooks when you want a client (API/library user, child classes etc.) to take optional actions at well-defined points in your control flow.

So a hook may be some function (given as e.g. an argument or a class method) that you call at a certain point e.g. during a database update:

data = beforeUpdate(data);

// ...update

afterUpdate(result);

Usually the point is that:

  • Hooks can be optional
  • Hooks usually are waited for i.e. they are there to modify some data
  • There is at most one function called per hook (contrary to events)

React makes use of hooks in its Hooks API, and they - quoting their definition - "are functions that let you “hook into” React state and lifecycle features", i.e. they let you change React state and also run custom functions each time when certain parts of the state change.

Events

In Javascript, events are emitted at certain points in time, and clients can subscribe to them. The functions that are called when an event happens are called listeners - or for added confusion, callbacks. I prefer to shun the term "callback" for this, and use the term "listener" instead.

This is also a generic OOP pattern.

In front-end there's a DOM interface for events, in node.js you have the EventEmitter interface. A sophisticated asynchronous version is implemented in ReactiveX.

Properties of events:

  • There may be multiple listeners/callbacks subscribed (to be executed) for the same event.
  • They usually don't receive a callback, only some event information and are run synchronously
  • Generally, and unlike hooks, they are not for modifying data inside the event emitter's control flow. The emitter doesn't care 'if there is anybody listening'. It just calls the listeners with the event data and then continues right away.

Examples: events happen when a data stream starts or ends, a user clicks on a button or modifies an input field.

Tags:

Hook

Callback

Recent Posts