Callbacks differ from other synchronous constructs like functions or loops in that they are asynchronous. This means that a function can call another function without waiting for it to finish executing before moving on to the next step. In contrast, functions and loops are executed sequentially, meaning that one task must be completed before the next begins.

Callbacks are preferred in certain situations where there is a need for asynchronous programming. One such situation would be when dealing with APIs or network requests. For example, if you were building an application that required data from an API, you would use a callback to retrieve the data without blocking the user interface. This allows the user to continue interacting with the application while the data is being retrieved in the background.

Here's an example of how callbacks can be used to retrieve data from an API:

const apiUrl = 'https://example.com/data';

function getData(callback) {
  fetch(apiUrl)
    .then(response => response.json())
    .then(data => callback(null, data))
    .catch(error => callback(error));
}

getData(data => {
  console.log(data);
});

In this example, the `getData` function takes a callback parameter which is used to retrieve the data from the API. The `fetch` method returns a promise which resolves with the data once it has been retrieved. The `then` method is used to specify what should happen when the promise resolves or rejects. In this case, if the data is retrieved successfully, it is passed as an argument to the callback function. If there is an error, it is also passed as an argument to the callback function with a `null` value as the first parameter.

Overall, callbacks are a powerful tool for building asynchronous applications in JavaScript. They allow developers to write code that is more efficient and responsive to user input, making for a better user experience.