Observables in Angular for http calls

Angular Observable Documentation

I was going through above angular observable documentation and in one section where they compare promises with observalbe the following point is give

> Observables provide many values. Promises provide one. This makes observables useful for getting multiple values over time.

So I am trying here to make a mental model of Observable and getting confused
So when they say Observable provide many values what does it mean

Like suppose i do a http call and observable will obviously return particular data(response)
Even promises will do same

And overtime api can either return with response or api might fail ,the same can done with promise as well

So whats the major difference while doing a http call using observable and promise

Apart from Promise executes immediately and Observable needs to be subscribed

It's because you're thinking about a wrong example. A HTTP call is by definition a single request-response cycle.

Consider instead something like mouse click.

Suppose you have a mouse click observer. You can execute your logic on every mouse click. In the javascript world we don't really need an observer pattern since event handlers are normal things in the language (they do however look and feel like the observer pattern without the boilerplate of a design pattern). So suppose you want to play a trumpet sound every time you click a button. You'd just do something like:

button.on('click', () => play_trumpet_sound());

On the other hand, a Promise can only happen once. So if the button exposes a Promise interface you'd instead need to do something like:

async function listenToClick () {
    while (1) {
        await button.getClick();

        play_trumpet_sound();
    }
}

listenToClick();

While Promises (and the async/await syntax that accompany them) are more concise and easier to use for a lot of use-cases, not all use-cases are better with Promises. When you need to listen for something that can happen again you're better off with regular callbacks (or in other languages the Observer pattern)