Яка різниця між кутовими Promise
та Observable
в них?
Приклад кожного з них буде корисним для розуміння обох випадків. У якому сценарії ми можемо використовувати кожен випадок?
Яка різниця між кутовими Promise
та Observable
в них?
Приклад кожного з них буде корисним для розуміння обох випадків. У якому сценарії ми можемо використовувати кожен випадок?
Відповіді:
Обіцяють
Ручка Promise
обробляє одну подію, коли операція асинхронізації завершена або завершена.
Примітка: Існують Promise
бібліотеки, які підтримують скасування, але ES6 Promise
поки не працює.
Спостерігається
An Observable
схожий на Stream
(багатьма мовами) і дозволяє передавати нуль або більше подій, де зворотний виклик викликається для кожної події.
Часто Observable
віддається перевагу над Promise
тим, що він забезпечує особливості Promise
та багато іншого. З Observable
цим не має значення, чи потрібно обробляти 0, 1 або кілька подій. Ви можете використовувати один і той же API в кожному випадку.
Observable
також має перевагу перед Promise
бути анульовані . Якщо результат запиту HTTP на сервер чи інша дорога операція з асинхронізацією більше не потрібен, Subscription
програма Observable
дозволяє скасувати підписку, в той час як a Promise
в кінцевому підсумку буде викликати успішний або невдалий зворотний дзвінок, навіть коли вам не потрібно повідомлення або результат, який він надає більше.
Спостережуване надає операторам , як map
, forEach
, reduce
, ... схожі на масив
Також є потужні оператори, такі як retry()
, або replay()
, ..., які часто дуже зручні.
Promise
разом із async
/ знову await
робить ваш код рівним! У більшості ситуацій, і в проектах, які не займаються ракетною наукою, немає необхідності писати ті жахливі вкладені функції з надмірно складними ланцюжками методів. Ви можете користуватися async
/ await
сьогодні з транспіляторами, як-от TypeScript
, і писати фактичний читаний людиною плоский код без жодної панелі rxjs
котла. Напевно, вам все одно знадобиться rxjs
іноді у вибраних ситуаціях, адже це дійсно є багато чого запропонувати.
І те, Promises
і інше Observables
надає нам абстракції, які допомагають нам боротися з асинхронним характером наших додатків. Різницю між ними чітко вказали @ Günter та @Relu.
Оскільки фрагмент коду коштує тисячу слів, перегляньте наведений нижче приклад, щоб зрозуміти їх легше.
Дякуємо @Christoph Burgdorf за приголомшливу статтю
Angular використовує Rx.js Спостереження замість обіцянок для роботи з HTTP.
Припустимо, ви будуєте функцію пошуку, яка повинна миттєво показувати результати під час введення тексту. Звучить звично, але є багато проблем, які постають перед цим завданням.
HTTP
запитів. В основному, ми хочемо вдарити його лише після того, як користувач перестане друкувати, а не кожен натискання клавіші.Демонстрація буде просто складатися з двох файлів: app.ts
і wikipedia-service.ts
. У реальному світовому сценарії ми, швидше за все, розділимо речі далі.
Нижче наведено реалізацію на основі обіцянок , яка не обробляє жоден із описаних крайових випадків.
wikipedia-service.ts
import { Injectable } from '@angular/core';
import { URLSearchParams, Jsonp } from '@angular/http';
@Injectable()
export class WikipediaService {
constructor(private jsonp: Jsonp) {}
search (term: string) {
var search = new URLSearchParams()
search.set('action', 'opensearch');
search.set('search', term);
search.set('format', 'json');
return this.jsonp
.get('http://en.wikipedia.org/w/api.php?callback=JSONP_CALLBACK', { search })
.toPromise()
.then((response) => response.json()[1]);
}
}
Ми пропонуємо Jsonp
сервісу зробити GET
запит проти API Вікіпедії із заданим пошуковим терміном. Зауважте, що ми зателефонували toPromise
, щоб дістатися з точки Observable<Response>
до а Promise<Response>
. Врешті-решт, вийде Promise<Array<string>>
як тип повернення нашого методу пошуку.
app.ts
// check the plnkr for the full list of imports
import {...} from '...';
@Component({
selector: 'my-app',
template: `
<div>
<h2>Wikipedia Search</h2>
<input #term type="text" (keyup)="search(term.value)">
<ul>
<li *ngFor="let item of items">{{item}}</li>
</ul>
</div>
`
})
export class AppComponent {
items: Array<string>;
constructor(private wikipediaService: WikipediaService) {}
search(term) {
this.wikipediaService.search(term)
.then(items => this.items = items);
}
}
Тут не так вже й багато сюрпризу. Ми вводимо нашу WikipediaService
і виставляємо її функціональність за допомогою методу пошуку до шаблону. Шаблон просто пов'язується з клавіатурою та дзвінками search(term.value)
.
Ми розгортаємо результат Обіцянки про те, що метод пошуку WikipediaService повертається та викриваємо його як простий масив рядків до шаблону, щоб ми могли *ngFor
пропустити його і створити список для нас.
Дивіться приклад Promise на основі реалізації на Plunker
Де спостереження дійсно сяють
Давайте змінимо наш код, щоб не забивати кінцеву точку при кожному натисканні клавіші, а натомість надсилатимемо запит лише тоді, коли користувач перестав друкувати на 400 мс.
Щоб розкрити такі суперпотужності, спочатку нам потрібно отримати знак, Observable<string>
який містить пошуковий термін, який вводить користувач. Замість того, щоб вручну прив’язуватися до події клавіатури, ми можемо скористатись formControl
директивою Angular . Щоб використовувати цю директиву, спочатку нам потрібно імпортувати ReactiveFormsModule
модуль до нашого додатка.
app.ts
import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { JsonpModule } from '@angular/http';
import { ReactiveFormsModule } from '@angular/forms';
@NgModule({
imports: [BrowserModule, JsonpModule, ReactiveFormsModule]
declarations: [AppComponent],
bootstrap: [AppComponent]
})
export class AppModule {}
Після імпорту ми можемо використовувати formControl з нашого шаблону і встановити його під назвою "термін".
<input type="text" [formControl]="term"/>
У нашому компоненті ми створюємо екземпляр FormControl
з @angular/form
і виставляємо його як поле під терміном імені нашого компонента.
За лаштунками термін автоматично розкриває Observable<string>
властивість як власність, на valueChanges
яку ми можемо підписатись. Тепер, коли у нас є Observable<string>
, подолати введення користувача так само просто, як і зателефонувати debounceTime(400)
на наш Observable
. Це поверне нове, Observable<string>
що випромінює нове значення лише тоді, коли не з’являються нові значення протягом 400 мс.
export class App {
items: Array<string>;
term = new FormControl();
constructor(private wikipediaService: WikipediaService) {
this.term.valueChanges
.debounceTime(400) // wait for 400ms pause in events
.distinctUntilChanged() // ignore if next search term is same as previous
.subscribe(term => this.wikipediaService.search(term).then(items => this.items = items));
}
}
Буде марно витрачати ресурси, щоб надіслати ще один запит на пошуковий термін, для якого наш додаток уже показує результати. Все, що нам потрібно зробити, щоб досягти бажаної поведінки - це викликати distinctUntilChanged
оператора відразу після того, як ми зателефонувалиdebounceTime(400)
Дивіться приклад спостережуваної реалізації на Plunker
Для розгляду відповідей, що не відповідають порядку, перегляньте повну статтю http://blog.thoughtram.io/angular/2016/01/06/taking-advantage-of-observables-in-angular2.html
Наскільки я використовую Http в Angular, я погоджуюся, що у звичайних випадках використання немає великої різниці при використанні Observable over Promise. Жодна з переваг тут насправді не актуальна на практиці. Сподіваюся, я можу побачити певний випадок розширеного використання в майбутньому :)
Вивчайте більше
І обіцянки, і спостереження допоможуть нам працювати з асинхронними функціоналами в JavaScript. Вони дуже схожі у багатьох випадках, проте, між ними все ще є деякі відмінності, обіцянки - це значення, які вирішаться asynchronous
таким чином, як http- дзвінки. З іншого боку, спостерігачі мають справу з послідовністю асинхронних подій . Основні відмінності між ними наведені нижче:
обіцянка:
помітний:
Також я створив для вас графічне зображення нижче, щоб наочно показати відмінності:
Promise
- неправильний спосіб думати про те, як обіцяє. Ви Promise
несете відповідальність лише за обробку успіху чи провалу сумісним чином з асинхрією. Якщо ви хочете скасувати запит http, ви скасуєте запит, а не обіцянку, і в результаті скасування або виконаєте Обіцяння. jsfiddle.net/greggman/ea0yhd4p
Обіцянки
Спостережні
Один оператор повтор може бути використаний , щоб повторити спробу , коли це необхідно, а також , якщо необхідно повторити спостерігаються на основі деяких умов retryWhen можуть бути використані.
Примітка : Список операторів разом з їх інтерактивними діаграмами доступний тут на RxMarbles.com
У відповідях є один недолік спостережень. Обіцяння дозволяють використовувати функції асинхронізації / очікування ES7. За допомогою них ви можете писати асинхронний код так, як це був би синхронний виклик функції, тому вам більше не потрібні зворотні дзвінки. Єдиною можливістю для спостерігачів це зробити - це перетворити їх на Обіцяння. Але перетворюючи їх у Обіцяння, ви можете знову мати лише одне повернене значення:
async function getData(){
const data = await observable.first().toPromise();
//do stuff with 'data' (no callback function needed)
}
Подальше читання: Як я можу "чекати" на Rx-спостережуваному?
Обіцянки та спостереження обробляють лише асинхронний виклик.
Ось відмінності між ними:
Спостерігається
Обіцяють
Одночасно випускає лише одне значення
Дзвінки на послуги без .then та .catch
Не можна скасувати
Не надає жодних операторів
Незважаючи на те, що ця відповідь запізнюється, я підсумував різниці нижче,
Спостерігається:
function
те, що приймає an observer
та повертає a function Observer: an object with next, error.
subscribe/unsubscribe
своєму потоку даних видавати наступне значення спостерігачеві, notify
спостерігачеві про errors
та інформувати спостерігача проstream completion
function to handle next value
, помилки та кінець потоку (події ui, відповіді http, дані з веб-сокетами).multiple values
часомcancel-able/retry-able
і підтримує операторів, таких як map,filter,reduce
і т.д.Observable.create()
- повертає спостережуване, що може викликати методи на - Observer Observable.from()
- перетворює масив або ітерабельний в - Observable Observable.fromEvent()
- перетворює подію в спостережуване - Observable.fromPromise()
- перетворює обіцянку в спостережуване - Observable.range()
- повертає послідовність цілих чисел у вказаному діапазоніОбіцянка :
Обіцянка являє собою завдання, яке завершиться в майбутньому;
Обіцянки стають resolved by a value
;
Обіцянки відхиляються винятками;
Ні, cancellable
і вона повертаєтьсяa single value
Обіцянка відкриває функцію (then)
-нато повертає нове promise
;
-дозволи на те, attachment
що буде виконано на основі
state
;
- handlers
підлягають guaranteed
виконанню order attached
;
Я щойно розглядав питання, де обіцянки були найкращим рішенням, і я ділюсь цим тут для тих, хто натрапляє на це питання у випадку, якщо це корисно (саме такий відповідь я шукав раніше):
У проекті Angular2 у мене є служба, яка приймає деякі параметри і повертає список значень для заповнення випадаючих меню форми. Коли компонент форми ініціалізується, мені потрібно викликати одну і ту ж службу кілька разів з різними параметрами, щоб визначити кількість різних спадних меню, однак, якщо я просто встановити в чергу всі змінні, щоб викликати службу, тільки остання успішна, а решта помилка з. Отримання служби з бази даних може обробляти лише один запит за один раз.
Єдиним способом успішного заповнення всіх змінних меню, що випадає, було викликати службу таким чином, щоб запобігти обробці нового запиту до останнього запиту, а механізм Обіцяння /. Потім вирішив проблему непогано.
fetchValueList(listCode): Promise<any> {
return this.dataSvc.getValueList(listCode, this.stateSvc.currentContext, this.stateSvc.currentLanguageCode)
.map(response => response.json())
.toPromise();
}
initializeDropDowns() {
this.fetchValueList('First-Val-List')
.then(data => {
this.firstValList = data;
return this.fetchValueList('Second-Val-List')
}).then(data => {
this.secondValList = data;
return this.fetchValueList('Third-Val-List')
}).then(data => {
this.thirdValList = data;
}) }
Я визначив функції компонента, а потім викликав InitializeDropDowns () в ngOnInit.
Функція fetchValueList повертає Promise, тому перший виклик передає перший listCode, і коли Promise вирішується, значення повернення знаходиться в змінній даних у блоці .then, де ми можемо призначити його цій змінній this.firstValList. Оскільки функція повертає дані, ми знаємо, що сервіс закінчено, і безпечно знову зателефонувати за допомогою другого listCode, значення, що повертається, знаходиться в змінній даних у наступному блоці.
Ми можемо це зробити ланцюжком стільки разів, скільки потрібно для заповнення всіх змінних, а на останньому блоці коду ми просто опускаємо оператор return і блок закінчується.
Це дуже специфічний випадок використання, коли ми маємо єдину службу, яку потрібно викликати кілька разів, коли компонент ініціалізується, і коли сервіс повинен завершити отримання та повернути значення, перш ніж його можна буде знову викликати, але в цьому випадку, метод «Обіцяння / .тем» був ідеальним.
scan()
для створення потоку послідовних спостережень. Однак ваш підхід, можливо, більш чіткий і простіший для розуміння.
Я вважаю, що всі інші відповіді повинні очистити ваші сумніви. Тим не менш, я просто хотів додати, що спостережливі дані базуються на функціональному програмуванні, і я вважаю дуже корисними функції, які поставляються з ним, як map, flatmap, уменьшення, zip. Послідовність, яку Інтернет досягає, особливо коли це залежить від запитів API, - жорстоке вдосконалення.
Я настійно рекомендую цю документацію , оскільки це офіційна документація reactiveX, і я вважаю, що вона є найбільш зрозумілою там.
Якщо ви хочете потрапити до спостережуваних даних, я б запропонував цей тришаровий пост: http://blog.danlew.net/2014/09/15/grokking-rxjava-part-1/
Хоча це призначено для RxJava, поняття однакові, і це дійсно добре пояснено. У документації на reakctiveX ви маєте еквіваленти для кожної функції. Ви повинні шукати RxJS.
Ви завжди можете використовувати спостережуване для боротьби з асинхронною поведінкою, оскільки спостерігаючий має всю функціональність, яку обіцянка пропонує (+ додатково). Однак іноді ця додаткова функціональність, яку пропонують спостерігачі, не потрібна. Тоді було б додатковим накладним імпортом бібліотеки для їх використання.
Використовуйте обіцянки, коли у вас є одна операція асинхронізації, з якої потрібно обробити результат. Наприклад:
var promise = new Promise((resolve, reject) => {
// do something once, possibly async
// code inside the Promise constructor callback is getting executed synchronously
if (/* everything turned out fine */) {
resolve("Stuff worked!");
}
else {
reject(Error("It broke"));
}
});
//after the promise is resolved or rejected we can call .then or .catch method on it
promise.then((val) => console.log(val)) // logs the resolve argument
.catch((val) => console.log(val)); // logs the reject argument
Тож обіцянка виконує якийсь код, де він або вирішує, або відхиляє. Якщо або вирішити, або відхилити, називається обіцянка переходить із стану, що перебуває у стані очікування, або до стану, яке було вирішено або відхилено . Коли стан обіцянки вирішено, then()
метод викликається. Коли стан обіцянки відхилено, catch()
метод викликається.
Використовуйте спостережні дані, коли протягом потоку часу є потік (даних), який потрібно обробляти. Потік являє собою послідовність елементів даних , які робляться доступні в протягом довгого часу . Прикладами потоків є:
У самому спостережуваному вказується, коли сталася наступна подія , коли виникає помилка або коли спостережуване завершено . Тоді ми можемо підписатися на цей спостережуваний, який його активує, і в цій підписці ми можемо передати 3 зворотних виклику (не завжди потрібно проходити у всіх). Один зворотний дзвінок, який потрібно виконати для успіху, один зворотний дзвінок за помилку та один зворотний дзвінок для завершення. Наприклад:
const observable = Rx.Observable.create(observer => {
// create a single value and complete
observer.onNext(1);
observer.onCompleted();
});
source.subscribe(
x => console.log('onNext: %s', x), // success callback
e => console.log('onError: %s', e), // error callback
() => console.log('onCompleted') // completion callback
);
// first we log: onNext: 1
// then we log: onCompleted
При створенні спостережуваної функції потрібна функція зворотного дзвінка, яка подає спостерігача як аргумент. На цьому спостерігач, то ви можете зателефонувати onNext
, onCompleted
, onError
. Потім, коли спостерігається підписка на нього, він буде викликати відповідні зворотні дзвінки, передані в підписку.
Обіцянка - надайте єдине майбутнє значення. Не лінивий. Не може скасувати. Він або відхилить, або вирішить.
Спостерігається - надайте кілька майбутніх цінностей. Ледачий. Відмовитись. Він надає інші методи живої карти, фільтрує, зменшує.
const promise = new Promise(resolve => {
setTimeout(() => {
resolve("Hello from a Promise!");
}, 2000);
});
promise.then(value => console.log(value));
Зараз помітний приклад. Тут також ми передаємо функцію спостережуваному, спостерігачеві для обробки завдання асинхронізації. На відміну від рішення в обіцянці, він має наступний метод і підписується замість того.
Таким чином обидва обробляють завдання асинхронізації. Тепер побачимо різницю.
const observable = new Observable(observer => {
setTimeout(() => {
observer.next('Hello from a Observable!');
}, 2000);
});
observable.subscribe(value => console.log(value));
Обіцяють
Спостерігається
І обіцянки, і спостереження допомагають нам мати справу з асинхронними операціями. Вони можуть викликати певні зворотні дзвінки, коли ці асинхронні операції виконуються.
Angular використовує Observables, який є від RxJS замість обіцянок для роботи з HTTP
Below are some important differences in promises & Observables.
Обіцяння випускає одну подію, коли активність асинхронізації закінчується або завершується невдачею.
Спостережуване схоже на Потік (багатьма мовами) і дозволяє передавати принаймні нуль або більше подій, де зворотний виклик необхідний для кожної події.
Часто спостерігається перевагу перед Promise, оскільки це дає основні моменти Promise та багато іншого. З "Спостережуваним" не має значення, чи потрібно обробляти 0, 1 або різні події. Ви можете використовувати аналогічний API для кожного випадку.
Обіцянка: обіцянка випромінює єдине значення
Наприклад:
const numberPromise = new Promise((resolve) => {
resolve(5);
resolve(10);
});
numberPromise.then(value => console.log(value));
// still prints only 5
Спостерігається: випромінює кілька значень протягом певного періоду часу
Наприклад:
const numberObservable = new Observable((observer) => {
observer.next(5);
observer.next(10);
});
numberObservable.subscribe(value => console.log(value));
// prints 5 and 10
ми можемо думати про спостережуваний, як потік, який випромінює декілька значень за певний проміжок часу, і та сама функція зворотного виклику викликається для кожного випущеного елемента, тому за допомогою спостережуваного ми можемо використовувати один і той же API для обробки асинхронних даних. чи передаються ці дані як одне значення або кілька значень протягом певного проміжку часу.
Обіцянка:
Спостерігається:
Promise випромінює одне значення, тоді як спостерігається - кілька значень. Так, під час обробки HTTP-запиту Promise може керувати однією відповіддю на той самий запит, але що робити, якщо на один запит є кілька відповідей, тоді нам доведеться використовувати Observable. Так, спостережуваний може обробляти кілька відповідей на один і той же запит.
Обіцяють
const promise = new Promise((data) =>
{ data(1);
data(2);
data(3); })
.then(element => console.log(‘Promise ‘ + element));
Вихідні дані
Promise 1
Спостерігається
const observable = new Observable((data) => {
data.next(1);
data.next(2);
data.next(3);
}).subscribe(element => console.log('Observable ' + element));
Вихідні дані
Observable 1
Observable 2
Observable 3
Нижче наведено кілька важливих відмінностей у обіцянках та спостереженнях.
Обіцяють
Спостерігається
Для кращого розуміння зверніться до https://stackblitz.com/edit/observable-vs-promises
Я бачу дуже багато людей, які використовують аргумент, що спостерігати "можна скасувати", але досить тривіально зробити обіцянку "скасовуваною"
function cancellablePromise(body) {
let resolve, reject;
const promise = new Promise((res, rej) => {
resolve = res; reject = rej;
body(resolve, reject)
})
promise.resolve = resolve;
promise.reject = reject;
return promise
}
// Example 1: Reject a promise prematurely
const p1 = cancellablePromise((resolve, reject) => {
setTimeout(() => resolve('10', 100))
})
p1.then(value => alert(value)).catch(err => console.error(err))
p1.reject(new Error('denied')) // expect an error in the console
// Example: Resolve a promise prematurely
const p2 = cancellablePromise((resolve, reject) => {
setTimeout(() => resolve('blop'), 100)
})
p2.then(value => alert(value)).catch(err => console.error(err))
p2.resolve(200) // expect an alert with 200
Коротка відповідь :
Спостережуваний є краще , вона має всі Обіцянки функції плюс додаткові функції.
Довга відповідь:
Обіцянки:
Спостерігається:
Хоча прийнята відповідь є загалом доброю, я не думаю, що вона підкреслює, що при роботі з кутовими компонентами ви майже завжди хочете використовувати спостережуваний, оскільки він підтримує скасування. Обіцяння не можна скасувати, і вони вирішаться, навіть якщо ваш компонент знищений. Кутовий має тенденцію прощати, поки цього не стане.
Наприклад, будь-яке ручне виявлення змін на знищеному компоненті спричинить виняток:
ngOnInit() {
// promise api
this.service.getData().then(d => {
this.data = d;
this.changeDetectorRef.detectChanges();
});
// observable api
this.service.getData().pipe(takeUntil(this.unsubscribe)).subscribe((d) => {
this.data = d;
this.changeDetectorRef.detectChanges();
});
}
Якщо ваш компонент знищений до того, як обіцянка буде вирішена, ви отримаєте attempt to use destroyed view
помилку, коли обіцянка буде вирішена.
Крім того, якщо ви використовуєте спостережувані дані разом із takeUntil малюнком , то, як тільки ваш компонент буде знищений, підписка буде скасована.
Це трохи надуманий приклад, але виконання коду для знищеного компонента, ймовірно, призведе до помилок. Якщо ви насправді не хочете це зробити чомусь: с
Щось, на що я зіткнувся, що було не видно з першого читання підручника, і в документах була ідея багатоадресної передачі.
Переконайтеся, що ви знаєте, що за замовчуванням кілька підписок спричинить багаторазове виконання у "Видимому". Багаторазові підписки на один HTTP-дзвінок, що спостерігається, ініціюють кілька однакових HTTP-дзвінків, якщо ви.share()
ввімкніть трансляцію.
Обіцянка змушує вас займатися однією справою, розгортати її дані, обробляти винятки, має мовну підтримку для класних речей, як-от асинхронізація / очікування, і в іншому випадку є досить босоніжними.
У спостережуваного багато дзвіночків, але вам потрібно зрозуміти, з якою силою ви працюєте, або це може бути неправильно використане.
Обіцянка:
Обробник подій Async - Об'єкт Promise являє собою можливе завершення (або збій) асинхронної операції та її отримане значення.
Синтаксис: нова Обіцянка (виконавець);
Наприклад:
var promise_eg = new Promise(function(resolve, reject) {
setTimeout(function() {
resolve('foo');
}, 300);
});
promise_eg.then(function(value) {
console.log(value);
// expected output: "foo"
});
console.log(promise_eg);
Про обіцянку: У неї є один конвеєр, тому він повертає значення лише один раз, коли його буде викликано. його односторонній обробник, щойно зателефонувавши вам, не зможе скасувати. корисний синтаксис, з яким можна грати, коли () і потім ()
Спостережні дані:
Спостережувані - це ліниві колекції численних значень у часі. це дійсно чудовий підхід для асинхронних операцій. це може бути зроблено за допомогою rxjs, який має підтримку міжплатформних платформ, можна використовувати з кутовими / реагувати тощо.
його діяти як потік лайнера. може бути багатопровідним. тож, визначившись, ви можете підписатися, щоб отримати результати повернення в багатьох місцях.
Синтаксис: import * as Rx from "@reactivex/rxjs";
init:
Rx.Observable.fromEvent(button, "click"),
Rx.Subject()
тощо
підписатися: RxLogger.getInstance();
Наприклад:
import { range } from 'rxjs';
import { map, filter } from 'rxjs/operators';
range(1, 200).pipe(
filter(x => x % 2 === 1),
map(x => x + x)
).subscribe(x => console.log(x));
оскільки він підтримує багатопровідний конвеєр, ви можете підписатися на результат у різних місцях, він має багато можливостей, ніж обіцянки.
Використання: у
нього більше можливостейmap, filter, pipe, map, concatMap etc
Спостереження часто порівнюють із обіцянками. Ось кілька ключових відмінностей:
Спостереження є декларативними; обчислення не починається до підписки. Обіцяння виконувати негайно по створенню. Це робить спостереження корисними для визначення рецептів, які можна виконувати, коли потрібен результат.
Спостережні дані дають багато значень. Обіцянки дають одне. Це робить спостережні дані корисними для отримання кількох значень у часі.
Спостережні дані розрізняють ланцюжок та передплату. Обіцянки мають лише пункти .then (). Це робить спостережливі корисними для створення складних рецептів перетворень, які використовуються в інших частинах системи, не викликаючи виконання роботи.
Спостерігачі передплатники () відповідають за обробку помилок. Обіцяє потік помилок дитини обіцянки. Це робить спостережні дані корисними для централізованого та передбачуваного поводження з помилками.
Це найпростіша різниця, яку ви можете знайти в документах ANGULAR.IO. відповідь про відпочинок дає більшість правильна у своєму місці
Обіцянки зосереджені лише на одиничних значеннях або на вирішеннях, спостережувані - це потік даних.
Спостереження можна скасувати, але обіцянки скасувати неможливо.
Найменш відомий, щонайменше, для мене
Спостереження та обіцянки допомагають нам працювати з асинхронними функціоналами в JavaScript / typecript. Вони дуже схожі у багатьох випадках, проте між ними все ж є деякі відмінності.
На цю тему вже багато відповідей, тому я не додав би зайвого.
Але тому, хто щойно почав вивчати Спостережливе / Кутове і цікавиться, який з них використовувати порівняти з Promise , я б рекомендував вам зберігати все спостережуване та перетворювати всі існуючі обіцянки у вашому проекті на спостережувані.
Просто тому, що самі Angular Framework та його спільнота використовують спостережуване. Тож було б вигідно, коли ви інтегруєте рамкові послуги або сторонні модулі та зв'язуєте все разом.
Хоча я ціную всі голоси, але все ж наполягаю на своїй думці вище, якщо хтось не додасть належного коментаря, щоб перерахувати декілька сценаріїв, які все ще можуть бути корисними у вашому проекті Angular, щоб використовувати Обіцянки над Спостережними.
Звичайно, жодна думка не є 100% правильною у всіх випадках, але, принаймні, я думаю, що 98% часу для регулярних комерційних проектів, що реалізуються в рамках Angular Framework, спостерігається - це правильний шлях.
Навіть якщо вам не сподобається на початковому етапі вашого простого хобі-проекту, незабаром ви зрозумієте, що майже всі компоненти, з якими ви взаємодієте в Angular, і більшість Angular дружелюбних третіх сторін використовують спостереження, і тоді ви в кінцевому підсумку постійно перетворював вашу Обіцянку на Спостережливе, щоб спілкуватися з ними.
Ці компоненти включають, але не обмежуються ними: HttpClient, Builder форм, модулі / діалоги кутових матеріалів, магазин / ефекти Ngrx та ngx-bootstrap.
Насправді єдина Обіцянка від Angular eco-системи, якою я займався за останні 2 роки APP_INITIALIZER
.