promises vs observables

Promises :

⛔️Promises are suitable for single asynchronous operations like fetching data from an API.promises are suitable for handling a single asynchronous value or error.

Observables :

⛔️Observables are ideal for handling streams of data, such as user input, WebSocket events, or HTTP responses, where multiple values might be emitted over time.

Table

Promises	Observables
Emit a single value at a time	Emit multiple values over a period of time.
Eager Execution: Promises are eager, meaning they start execution immediately after creation.Are not cancellable.	Are lazy: they’re not executed until we subscribe to them using the subscribe() method.
Don’t provide any operations	Provide the map for forEach, filter, reduce, retry, and retryWhen operators.Leverage Rxjs with Observables
Push errors to the child promises	Deliver errors to the subscribers.
Immutable: Once a promise is settled (either resolved or rejected), its state cannot be changed.	Mutable: Observables are mutable and can emit multiple values over time.

Promise Syntax:

   
      

const promise = new Promise((resolve, reject) => {
  // Asynchronous operation
  if (/* operation successful */) {
    resolve(result);
  } else {
    reject(error);
  }
});

promise.then(
  (result) => {
    // handle success
  },
  (error) => {
    // handle error
  }
);
              
              
              

Observable Syntax:

   
    
  
  import { Observable } from 'rxjs';

const observable = new Observable((observer) => {
  // Asynchronous operation
  if (/* operation successful */) {
    observer.next(result);
    observer.complete();
  } else {
    observer.error(error);
  }
});

const subscription = observable.subscribe(
  (value) => {
    // handle each value
  },
  (error) => {
    // handle error
  },
  () => {
    // handle completion
  }
);

// Unsubscribe when done
subscription.unsubscribe();