Angular Promise
와 Observable
Angular 의 차이점은 무엇입니까 ?
각각의 예는 두 경우를 이해하는 데 도움이 될 것입니다. 어떤 경우에 우리는 각 경우를 사용할 수 있습니까?
Angular Promise
와 Observable
Angular 의 차이점은 무엇입니까 ?
각각의 예는 두 경우를 이해하는 데 도움이 될 것입니다. 어떤 경우에 우리는 각 경우를 사용할 수 있습니까?
답변:
약속
비동기 작업이 완료되거나 실패하면 A Promise
는 단일 이벤트를 처리 합니다.
참고 : Promise
취소를 지원하는 라이브러리가 있지만 ES6 Promise
은 아직까지는 그렇지 않습니다.
주목할 만한
은 Observable
유사한입니다 Stream
(여러 언어로) 콜백이 각 이벤트에 대해 호출됩니다 0 개 이상의 이벤트를 전달할 수 있습니다.
자주 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는 HTTP 처리 약속 대신 Rx.js Observables를 사용합니다.
입력하는 즉시 결과를 표시 하는 검색 기능 을 구축한다고 가정하십시오 . 친숙하게 들리지만 그 과제에는 많은 어려움이 있습니다.
HTTP
. 기본적으로, 우리는 사용자가 모든 키 입력 대신 입력을 중지 한 후에 만 치고 싶습니다.데모는 단순히 두 개의 파일로 구성됩니다 : app.ts
와 wikipedia-service.ts
. 실제 시나리오에서 우리는 아마도 상황을 더 나눌 것입니다.
아래는 설명 된 엣지 케이스를 처리하지 않는 Promise 기반 구현입니다.
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]);
}
}
지정된 검색어로 Wikipedia API 에 대해 요청 하는 Jsonp
서비스를 제공하고 있습니다. 에서로 이동하기 위해 호출 합니다 . 결국 검색 방법의 반환 유형 으로 a 로 끝납니다 .GET
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
반복하고 목록을 작성할 었다.
Plunker 에서 Promise 기반 구현 의 예를 참조하십시오
어디 Observable 인은 정말 빛
키를 누를 때마다 끝점을 망치지 말고 사용자가 400ms 동안 입력을 중지했을 때만 요청을 보내도록 코드를 변경해 봅시다.
이러한 초강대국을 공개하려면 먼저 Observable<string>
사용자가 입력 한 검색어를 포함하는 검색어를 가져와야합니다. 키업 이벤트에 수동으로 바인딩하는 대신 Angular의 formControl
명령어를 활용할 수 있습니다 . 이 지시문을 사용하려면 먼저 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을 사용하여 "term"이라는 이름으로 설정할 수 있습니다.
<input type="text" [formControl]="term"/>
컴포넌트 FormControl
에서 from 의 인스턴스를 만듭니다@angular/form
우리의 구성 요소에 이름 용어 아래 필드로 노출됩니다.
배후에서 용어 는 구독 할 수 있는 Observable<string>
as 속성 valueChanges
을 자동으로 노출합니다 . 이제 Observable<string>
사용자 입력을 극복하는 것은을 호출 debounceTime(400)
하는 것만 큼 쉽습니다 Observable
. Observable<string>
400ms 동안 새로운 값이 나오지 않을 때만 새로운 값을 방출하는 새로운 값 을 반환합니다 .
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 에서 Observable 구현 예제를 참조하십시오
순서가 잘못된 응답을 처리하려면 전체 기사 http://blog.thoughtram.io/angular/2016/01/06/taking-advantage-of-observables-in-angular2.html을 확인하십시오.
Angular에서 Http를 사용하는 한 일반적인 사용 사례에서는 Observable over Promise를 사용할 때 큰 차이가 없다는 데 동의합니다. 실제로 어떤 이점도 실제로 관련이 없습니다. 앞으로 고급 사용 사례를 볼 수 있기를 바랍니다. :)
더 알아보기
모두 약속 과 Observables은이 우리에게 일을 도움이 될 것입니다 비동기 기능을 자바 스크립트입니다. 그것들은 많은 경우에 매우 유사하지만, 둘 사이에도 여전히 약간의 차이가 있습니다. 약속은 http 호출 asynchronous
과 같은 방식으로 해결되는 값입니다 . 반면, 관찰 가능 항목은 일련의 비동기 이벤트를 처리합니다 . 이들의 주요 차이점은 다음과 같습니다.
약속:
주목할 만한:
또한 차이점을 시각적으로 보여주기 위해 아래의 그래픽 이미지를 만들었습니다.
Promise
것은 약속 방법에 대해 생각하는 잘못된 방법입니다. Promise
비동기 호환 방식으로 만 핸들 성공 또는 실패의 책임이 ... 당신이 요청하지 약속을 취소 HTTP 요청을 취소하고 이행 또는 약속을 거부하거나 취소의 결과를 확인하려면. jsfiddle.net/greggman/ea0yhd4p
약속
관찰 가능
한 운영자 재 시도는 우리가 어떤 조건에 따라 관찰을 재 시도 할 필요도 경우에, 필요할 때마다 다시 시도 할 수 있습니다 retryWhen가 사용할 수 있습니다.
참고 : 대화식 다이어그램과 함께 운영자 목록은 RxMarbles.com 에서 확인할 수 있습니다.
답변에 Observables의 단점이 하나 있습니다. 약속은 ES7 비동기 / 대기 기능을 사용할 수 있습니다. 그것들을 사용하면 동기 함수 호출처럼 비동기 코드를 작성할 수 있으므로 더 이상 콜백이 필요하지 않습니다. Observables가이를 수행 할 수있는 유일한 가능성은 약속으로 변환하는 것입니다. 그러나이를 약속으로 변환하면 다시 한 번의 반환 값만 가질 수 있습니다.
async function getData(){
const data = await observable.first().toPromise();
//do stuff with 'data' (no callback function needed)
}
추가 읽을 거리 : Rx Observable에서 어떻게 '기다릴'수 있습니까?
약속 및 관찰 가능 항목은 모두 비동기 호출 만 처리합니다.
차이점은 다음과 같습니다.
주목할 만한
약속
한 번에 하나의 값만 방출
.then 및 .catch없이 서비스를 호출합니다.
취소 할 수 없습니다
운영자를 제공하지 않습니다
이 답변이 늦었지만 아래 차이점을 요약했습니다.
주목할 만한:
function
소요 an observer
와 리턴한다 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 프로젝트에는 일부 매개 변수를 사용하고 값 목록을 반환하여 양식의 드롭 다운 메뉴를 채우는 서비스가 있습니다. 양식 구성 요소가 초기화되면 여러 다른 드롭 다운 메뉴를 정의하기 위해 다른 매개 변수로 동일한 서비스를 여러 번 호출해야하지만 서비스를 호출하기 위해 모든 변수를 대기열에 넣으면 마지막 변수 만 성공하고 나머지 오류 만 발생합니다 밖. 데이터베이스에서 가져 오는 서비스는 한 번에 하나의 요청 만 처리 할 수 있습니다.
모든 드롭 다운 메뉴 변수를 성공적으로 채우는 유일한 방법은 마지막 요청이 완료 될 때까지 새 요청이 처리되지 않도록하는 방식으로 서비스를 호출하는 것이 었으며 Promise / .then 메커니즘은 문제를 훌륭하게 해결했습니다.
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;
}) }
구성 요소에서 함수를 정의한 다음 ngOnInit에서 initializeDropDowns ()를 호출했습니다.
fetchValueList 함수는 Promise를 반환하므로 첫 번째 호출은 첫 번째 listCode를 전달하고 Promise가 해결되면 반환 값은 this.firstValList 변수에 할당 할 수있는 .then 블록의 데이터 변수에 있습니다. 함수가 데이터를 반환 했으므로 서비스가 완료되었으며 두 번째 listCode를 사용하여 다시 호출하는 것이 안전하며 반환 값은 다음 .then 블록의 데이터 변수에 있으며 this.secondValList 변수에 할당됩니다.
모든 변수를 채우는 데 필요한만큼 이것을 체인으로 묶을 수 있으며 마지막 코드 블록에서는 단순히 return 문을 생략하고 블록이 종료됩니다.
이것은 컴포넌트가 초기화 될 때 여러 번 호출해야하는 단일 서비스가 있고 서비스를 다시 호출하기 전에 페치를 완료하고 값을 리턴해야하는 매우 구체적인 유스 케이스입니다. Promise / .then 방법이 이상적입니다.
scan()
순차적 관측 가능 스트림을 작성하는 데 사용할 수 있습니다. 그러나 귀하의 접근 방식은 더 명확하고 이해하기 쉽습니다.
다른 모든 답변은 의심을 없애야한다고 생각합니다. 그럼에도 불구하고, 나는 Observable이 함수형 프로그래밍을 기반으로하고 있다는 것을 덧붙이고 싶었고, map, flatmap, reduce, zip과 같은 기능이 매우 유용하다는 것을 알았습니다. 특히 웹이 API 요청에 의존 할 때 달성하는 일관성은 대단한 개선입니다.
ReactiveX의 공식 문서이므로이 문서를 강력히 추천 합니다 .
관찰 가능 항목에 들어가려면이 3 부분 게시물을 제안합니다 .http : //blog.danlew.net/2014/09/15/grokking-rxjava-part-1/
RxJava를위한 것이지만 개념은 동일하며 실제로 잘 설명되어 있습니다. ReactiveX 문서에는 각 기능에 해당하는 내용이 있습니다. RxJS를 찾아야합니다.
옵저버 블에는 약속이 제공하는 모든 기능 (+ 추가)이 있으므로 비동기식 동작을 처리하기 위해 항상 옵저버 블을 사용할 수 있습니다. 그러나 때때로 Observables가 제공하는이 추가 기능이 필요하지 않습니다. 그러면 라이브러리를 사용하기 위해 라이브러리를 가져 오는 것이 추가 오버 헤드가됩니다.
결과를 처리하려는 단일 비동기 작업 이있는 경우 약속을 사용하십시오 . 예를 들면 다음과 같습니다.
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()
메서드가 호출됩니다.
처리해야하는 시간 이 지남에 따라 데이터 스트림 이있는 경우 Observables를 사용하십시오 . 스트림은 시간이 지남에 따라 사용 가능한 일련의 데이터 요소입니다 . 스트림의 예는 다음과 같습니다.
관찰에서 자체는 때 지정된 다음 이벤트가 일어난 경우, 오류가 발생 하거나 관찰이 될 때 완료 . 그런 다음이 Observable을 구독하면 활성화되며이 구독에서는 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
. 그런 다음 Observable이 구독되면 구독에 전달 된 해당 콜백을 호출합니다.
const promise = new Promise(resolve => {
setTimeout(() => {
resolve("Hello from a Promise!");
}, 2000);
});
promise.then(value => console.log(value));
이제 관찰 가능한 예입니다. 여기에서는 비동기 작업을 처리하는 관찰자, 관찰자에게 함수를 전달합니다. 약속의 resolve와 달리 다음 방법이 있으며 대신 구독합니다.
따라서 둘 다 비동기 작업을 처리합니다. 이제 차이점을 보자.
const observable = new Observable(observer => {
setTimeout(() => {
observer.next('Hello from a Observable!');
}, 2000);
});
observable.subscribe(value => console.log(value));
약속
주목할 만한
Promises와 Observables는 비동기 작업을 처리하는 데 도움이됩니다. 이러한 비동기 작업이 완료되면 특정 콜백을 호출 할 수 있습니다.
Angular는 HTTP 처리 약속 대신 RxJS의 Observable을 사용합니다.
Below are some important differences in promises & Observables.
비동기 활동이 완료되거나 실패하면 약속은 단일 이벤트를 생성합니다.
Observable은 Stream (다국어)과 유사하며 모든 이벤트에 콜백이 필요한 경우 0 개 이상의 이벤트를 전달할 수 있습니다.
Promise 등의 주요 기능을 제공하므로 Promise보다 자주 Observable이 선호됩니다. Observable을 사용하면 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
우리는 일정 기간 동안 여러 값을 방출하는 스트림과 같은 observable을 생각할 수 있으며 방출되는 각 항목에 대해 동일한 콜백 함수가 호출되므로 observable과 함께 동일한 API를 사용하여 비동기 데이터를 처리 할 수 있습니다. 해당 데이터가 일정 시간 동안 단일 값 또는 다중 값으로 전송되는지 여부
약속:
주목할 만한:
Promise는 단일 값을 내보내고 Observable은 여러 값을 내 보냅니다. 따라서 HTTP 요청을 처리하는 동안 Promise는 동일한 요청에 대한 단일 응답을 관리 할 수 있지만 동일한 요청에 대한 여러 응답이있는 경우 Observable을 사용해야합니다. 예, 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를 참조 하십시오
나는 Observable이 "cancellable"이라는 주장을 사용하는 많은 사람들을 보지만 Promise를 "cancellable"로 만드는 것은 사소한 일이다
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
짧은 답변 :
Observable 이 더 좋으며 , 모든 Promises 기능과 추가 기능이 있습니다.
긴 대답 :
약속 :
주목할 만한:
허용되는 대답은 일반적으로 좋지만 각도 구성 요소를 다룰 때 취소를 지원하기 때문에 Observable을 거의 항상 사용하고 싶다고 강조하지는 않습니다. 약속은 취소 할 수 없으며 구성 요소가 파손 된 경우에도 해결됩니다. Angular는 그렇지 않을 때까지 용서하는 경향이 있습니다.
예를 들어 손상된 구성 요소에서 수동 변경을 감지하면 예외가 발생합니다.
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 패턴으로 옵저버 블 을 사용하는 경우 구성 요소가 손상 되 자마자 구독이 취소됩니다.
이것은 약간의 고안된 예이지만 파괴 된 구성 요소에 대한 코드를 실행하면 버그가 발생할 수 있습니다. 실제로 어떤 이유로 든 그렇게하지 않으려는 경우 : p
내가 강의 한 것은 튜토리얼과 문서를 처음 읽었을 때 분명하지 않았지만 멀티 캐스팅이라는 아이디어였습니다.
기본적으로 여러 구독이 Observable에서 여러 실행을 트리거한다는 것을 알고 있어야합니다. 단일 HTTP 호출에 대한 다중 구독 Observable은 .share()
멀티 캐스팅을 활성화 하지 않는 한 동일한 HTTP 호출을 여러 번 트리거합니다 .
약속은 한 번에 한 가지만 처리하고, 데이터를 압축 해제하고, 예외를 처리하고, 비동기 / 대기 등의 멋진 기능에 대한 언어 지원을 제공하며, 그렇지 않은 경우에는 매우 중요합니다.
Observable은 많은 종과 휘파람을 가지고 있지만 작업하는 힘을 이해해야하거나 잘못 사용할 수 있습니다.
약속:
비동기 이벤트 처리기-Promise 개체는 비동기 작업의 최종 완료 및 결과 값을 나타냅니다.
통사론: new Promise (executor);
예 :
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);
Promise 정보 : 파이프 라인이 하나이므로 호출 될 때 한 번만 값을 반환합니다. 한 번만 호출하면 취소 할 수 없습니다. when () 와 then () 을 사용할 수있는 유용한 구문
관찰 가능 항목 :
Observable은 시간이 지남에 따라 여러 값의 게으른 모음입니다. 비동기 작업에 대한 훌륭한 접근 방식입니다. 이 수행 할 수 있습니다 rxjs 각도에서 사용할 수있는 크로스 플랫폼 지원을하고있다 / 등 반응
스트림 라이너처럼 작동합니다. 다중 파이프 라인 일 수 있습니다. 일단 정의되면 구독하면 여러 곳에서 결과를 얻을 수 있습니다.
구문 : import * as Rx from "@reactivex/rxjs";
초기화 :
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
옵저버 블은 종종 약속과 비교됩니다. 주요 차이점은 다음과 같습니다.
관찰 가능한 내용은 선언적입니다. 가입 할 때까지 계산이 시작되지 않습니다. 약속은 창조 즉시 실행됩니다. 이것은 결과물이 필요할 때마다 실행될 수있는 레시피를 정의하는 데 관측 값을 유용하게 만듭니다.
Observable은 많은 가치를 제공합니다. 약속은 하나를 제공합니다. 따라서 관측 가능 항목은 시간이 지남에 따라 여러 값을 가져 오는 데 유용합니다.
옵저버 블은 체인과 구독을 구분합니다. 약속에는 .then () 절만 있습니다. 이로 인해 Observables는 작업을 실행하지 않고도 시스템의 다른 부분에서 사용할 복잡한 변환 레시피를 만드는 데 유용합니다.
Observables subscribe ()는 오류 처리를 담당합니다. 약속은 자녀의 약속에 오류를 미칩니다. 이는 관측 가능 항목을 중앙 집중식 및 예측 가능한 오류 처리에 유용하게 만듭니다.
이것이 ANGULAR.IO 문서에서 찾을 수있는 가장 간단한 차이점입니다. 나머지 답변은 대부분 자체 장소에서 정확합니다.
이 주제에 대해 이미 많은 답변이 있으므로 중복 항목을 추가하지 않습니다.
그러나 Observable / Angular를 배우기 시작한 사람에게 Promise 와 비교하여 사용할 것을 궁금해하는 사람에게는 모든 Observable을 유지하고 프로젝트의 모든 기존 약속을 Observable로 변환하는 것이 좋습니다.
Angular 프레임 워크 자체와 커뮤니티가 모두 Observable을 사용하기 때문에 간단합니다. 따라서 프레임 워크 서비스 또는 타사 모듈을 통합하고 모든 것을 함께 연결할 때 도움이됩니다.
모든 다운 보트에 감사하지만 누군가가 Obularables에 대한 약속을 사용하는 Angular 프로젝트에서 여전히 유용 할 수있는 몇 가지 시나리오를 나열하기 위해 적절한 의견을 제시하지 않는 한 위의 견해를 주장합니다.
물론, 모든 경우에 100 % 정확한 의견은 없지만 적어도 Angular 프레임 워크에서 구현 된 일반 상용 프로젝트의 경우 98 %가 올바른 방법이라고 생각합니다.
간단한 취미 프로젝트의 시작점에서 마음에 들지 않더라도 Angular에서 상호 작용하는 거의 모든 구성 요소를 곧 깨닫게 될 것입니다. Angular 친화적 인 타사 프레임 워크의 대부분은 Observables를 사용하고 있습니다. 그들과 대화하기 위해 약속을 지속적으로 Observable로 변환했습니다.
이러한 구성 요소에는 HttpClient, Form builder, Angular 재질 모듈 / 대화 상자, Ngrx 저장 / 효과 및 ngx-bootstrap이 포함됩니다.
실제로 지난 2 년 동안 내가 처리 한 Angular 에코 시스템의 유일한 약속은 APP_INITIALIZER
입니다.