약속과 관찰의 차이점은 무엇입니까?


1396

Angular PromiseObservableAngular 의 차이점은 무엇입니까 ?

각각의 예는 두 경우를 이해하는 데 도움이 될 것입니다. 어떤 경우에 우리는 각 경우를 사용할 수 있습니까?


23
나는 당신이이 포스트를 읽는 것이 좋습니다; Angular2 promise vs observable
erolkaya84


3
이 Q & A를 읽는 사람에게-관리자, 연사 및 오랜 사용자 PoV의 두 세계에 관련된 사람으로서 약속에 대한 공식 RxJS 문서와 MDN 문서를 읽는 것이 좋습니다. 나는 개인적으로 여기에있는 대답이 완전히 오도되고 부정확 하다는 것을 발견하고 도움이되는 사람들의 좋은 의도와 함께 매우 해 롭습니다.
Benjamin Gruenbaum

1
이 각도 공식 문서 angular.io/guide/comparing-observables
fgul

그리고 이것이 링크가 대답으로 받아 들일 수없는 것으로 간주되는 이유입니다.
Dave

답변:


1548

약속

비동기 작업이 완료되거나 실패하면 A Promise단일 이벤트를 처리 합니다.

참고 : Promise취소를 지원하는 라이브러리가 있지만 ES6 Promise은 아직까지는 그렇지 않습니다.

주목할 만한

Observable유사한입니다 Stream(여러 언어로) 콜백이 각 이벤트에 대해 호출됩니다 0 개 이상의 이벤트를 전달할 수 있습니다.

자주 Observable 그 이상의 Promise기능을 제공하기 때문에 선호 Promise됩니다. 으로 Observable당신은 0, 1, 또는 여러 이벤트를 처리 할 경우 문제가되지 않습니다. 각 경우에 동일한 API를 사용할 수 있습니다.

Observable또한보다 장점 Promise 취소 . 서버 나 다른 고가의 비동기 작업에 대한 HTTP 요청의 결과가 더 이상 필요하지 않은 경우, Subscription의는 ObservableA가 동안 가입을 취소 할 수 있습니다 Promise당신은 통지를 필요로하지 않는 경우에도 결국 성공 또는 실패 콜백을 호출합니다 또는 더 이상 제공되는 결과.

관찰 가능 사업자 와 같은 map, forEach, reduce배열과 유사한을 ...

강력한 같은 사업자도있다 retry(), 또는 replay()종종 매우 편리합니다 ....


180
따라서 단일 콜백 사례에서 Observable 대신 Promise를 사용해야 할 합당한 이유가 있습니까? 아니면 Observable도 그렇게 할 수 있기 때문에 Observable도 사용해야합니까? 기본적으로 "모든 것을 관찰 할 수있는"것이 좋습니까, 아니면 약속이 여전히 그 자리에 있습니까?
Josh Werts

75
반응 형 스타일을 사용하려면 모든 곳에서 관찰 가능 항목을 사용하십시오. 관찰 가능 항목 만 있으면 쉽게 작성할 수 있습니다. 당신이 그들을 혼합하면 더 이상 깨끗하지 않습니다. 반응 형 스타일에 신경 쓰지 않으면 이벤트 스트림에 대해 취소 가능하고 관찰 가능하지 않은 단일 이벤트에 대한 약속을 사용할 수 있습니다.
Günter Zöchbauer

35
@ GünterZöchbauer Hey-Observable이나 함수형 프로그래밍에 대한 논쟁은 없습니다. 나는 단순히 NG2에서 http를 통해 Observables에 접속하는 사람들이 Prospectes를 통해 Observables를 사용하여 전화를 걸어야 할 이유가 없다고 믿는다. 그들은 약속을 사용함으로써 실질적인 것을 잃지 않습니다. 디 바운스 및 재시도 연산자는 관련이 없습니다. ng-debounce를 사용하여 디 바운스 할 수 있으며 호출이 실패 할 것으로 예상되는 경우 일반적으로 코드에 문제가 있습니다. 호출을 다시 시도하는 데 필요한 유일한 시간은 HVT에 대해 불안정한 타사 API를 쿼리하는 동안이었습니다.
VSO

92
그러나 잊지 마십시오 Promise과 함께 async/ await다시 코드를 평평하게! 로켓 과학을 다루지 않는 대부분의 상황과 프로젝트에서는 불필요하게 복잡한 일련의 방법으로 끔찍한 중첩 함수를 작성할 필요가 없습니다. async/ await와 같은 트랜스 파일러와 함께 / 오늘 사용할 수 있으며 상용구 TypeScript없이 실제 사람이 읽을 수있는 플랫 코드를 작성할 수 rxjs있습니다. rxjs실제로 제공해야 할 것이 많기 때문에 선택 상황에 따라 필요할 수도 있습니다.
evilkos

15
이 답변은 오해의 소지가 있습니다. Observable은 stream과 같지 않으며 stream 을 반환하는 함수 와 같습니다 .
Benjamin Gruenbaum

334

모두 PromisesObservables도움을 우리가 다루는 것을 추상화를 제공해 비동기 우리의 응용 프로그램의 성격. 그들 사이의 차이점은 @ Günter와 @Relu에 의해 명확하게 지적되었습니다.

코드 스 니펫은 천 단어의 가치가 있으므로 아래 예제를 통해 쉽게 이해할 수 있습니다.

멋진 기사에 대해 Christoph Burgdorf에게 감사드립니다.


Angular는 HTTP 처리 약속 대신 Rx.js Observables를 사용합니다.

입력하는 즉시 결과를 표시 하는 검색 기능 을 구축한다고 가정하십시오 . 친숙하게 들리지만 그 과제에는 많은 어려움이 있습니다.

  • 우리는 사용자가 키를 누를 때마다 서버 엔드 포인트에 충돌하지 않기를 원합니다. HTTP . 기본적으로, 우리는 사용자가 모든 키 입력 대신 입력을 중지 한 후에 만 ​​치고 싶습니다.
  • 동일한 쿼리 매개 변수로 검색 엔드 포인트를 누르지 마십시오.후속 요청에 대해 를 .
  • 순서가 잘못된 응답을 처리합니다. 기내에서 여러 건의 요청이 동시에 발생하는 경우 예상치 못한 순서로 되돌아 오는 사례를 고려해야합니다. 먼저 컴퓨터를 입력하고 , 중지하고, 요청이 나가고, 자동차 를 입력하고, 중지하고, 요청이 나가는 것을 상상해보십시오 . 이제 기내에서 두 가지 요청이 있습니다. 불행히도 컴퓨터에 대한 결과를 전달하는 요청은 car에 대한 결과를 전달하는 요청 후에 다시 발생합니다 .

데모는 단순히 두 개의 파일로 구성됩니다 : app.tswikipedia-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 로 끝납니다 .GETtoPromiseObservable<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를 사용할 때 큰 차이가 없다는 데 동의합니다. 실제로 어떤 이점도 실제로 관련이 없습니다. 앞으로 고급 사용 사례를 볼 수 있기를 바랍니다. :)


더 알아보기


31
HTTP 서비스를 Observable 기반으로 전환하기로 한 결정을 완전히 구입하지는 않습니다. 내가 듣는 모든 설명은 동일한 예에 의존합니다. 용어 별 검색. 그러나 그 중 하나는 브라우저 이벤트 처리에 관한 것입니다. 비동기 http 요청을 처리 할 때 이점을 적용하면 어떤 이점이 있는지 듣고 싶습니다.
Alex Pollan

1
패턴이 혼합 된 패턴을 피하기 위해 우연히 결정 되었습니까?
Alex Pollan

6
: @AlexPollan 실제로 벤 레 쉬는이 팟 캐스트에 관찰을 반환 HTTP 서비스의 혜택에 대한 좋은 설명이있다 devchat.tv/js-jabber/... . 궁극적으로 주요 이점은 관찰 가능 항목을 취소 할 수 있다는 것입니다. 위의 링크에 설명 된 유스 케이스는 약간의 생각이 들지만 여러 API를 호출하고 첫 번째 응답 만 신경 쓰면 당신이 전화 한 apis의 첫 번째 당신에게 돌아온 다음 당신은 다른 사람에 대한 요청을 취소 할 수 있습니다.
nikolasleblanc

2
@ nikolasleblanc, 내가 $ q.race () 사용할 수 있다고 확신합니까?
jameslouiz

2
@AlexPollan의 장점은 Observable 기반 HTTP 서비스를 통해 비행 중 HTTP 요청을 쉽게 취소 할 수 있다는 것입니다. trungk18의 답변에있는 경쟁 조건은 후속 요청을하기 전에 HTTP 관찰 가능 항목을 구독 취소하면 해결할 수 있습니다. RXJS switchMap은 다른 관찰 가능 항목 (예 : valueChanges)에 의해 트리거 된 HTTP 요청에 사용할 수 있습니다. 독립형 HTTP 옵저버 블의 경우 수동으로 구독을 취소하고 다시 구독 할 수 있습니다.
Stevethemacguy

235

모두 약속Observables은이 우리에게 일을 도움이 될 것입니다 비동기 기능을 자바 스크립트입니다. 그것들은 많은 경우에 매우 유사하지만, 둘 사이에도 여전히 약간의 차이가 있습니다. 약속은 http 호출 asynchronous과 같은 방식으로 해결되는 값입니다 . 반면, 관찰 가능 항목은 일련의 비동기 이벤트를 처리합니다 . 이들의 주요 차이점은 다음과 같습니다.

약속:

  • 하나의 파이프 라인을 갖는 것
  • 일반적으로 비동기 데이터 반환에만 사용
  • 취소하기 쉽지 않다

주목할 만한:

  • 취소 할 수있다
  • 재시도 및 재시 도와 같은 특성상 재시도 가능
  • 여러 파이프 라인에서 데이터 스트리밍
  • 맵, 필터 등과 같은 배열과 유사한 작업
  • 이벤트와 같은 다른 소스에서 만들 수 있습니다
  • 그것들은 나중에 구독 할 수있는 기능입니다.

또한 차이점을 시각적으로 보여주기 위해 아래의 그래픽 이미지를 만들었습니다.

약속과 관찰 가능 이미지


4
"취소하기 쉽지 않다"고 약속하면 취소 할 수 있습니까?
Pardeep Jain

10
예, 취소하는 방법도 있습니다 ... 어떤 사람들은 블루 버드 또는 타사 라이브러리를 사용합니다 ... Angular에서 Q 라이브러리를 사용하면 취소하는 방법이 있습니다 ...하지만 매우 편리하지는 않습니다.
Alireza

하나의 파이프 라인을 갖는 것은 때때로 이점이있다. APP_INITIALIZER에서 여러 파이프 라인이있는 경우 때때로 완료하거나 여러 번 완료 할 수 없습니다.
windmaomao

6
a를 취소하는 Promise것은 약속 방법에 대해 생각하는 잘못된 방법입니다. Promise비동기 호환 방식으로 만 핸들 성공 또는 실패의 책임이 ... 당신이 요청하지 약속을 취소 HTTP 요청을 취소하고 이행 또는 약속을 거부하거나 취소의 결과를 확인하려면. jsfiddle.net/greggman/ea0yhd4p
gman

2
@gman 정확합니다. 약속은 단순히 미래의 가치 를 나타냅니다 . 그것은 않는 하지 나타내는 값을 생성하는 동작 . 값을 취소 할 수 없습니다. 값을 재 시도 할 수 없습니다. 그것은 단지 가치입니다. 아직 존재 하거나 존재 하지 않을 수 있으며 예외가 발생하여 존재 하지 않을 수도 있지만 그게 전부입니다.
Yona Appletree

75

약속

  1. 정의 : 함수를 비동기식으로 실행하고 반환 값 (또는 예외)을 한 번만 사용하도록 도와줍니다. 실행하고 실행시 .
  2. 게으른
  3. 취소 할 수 없음 (취소를 지원하는 Promise 라이브러리가 있지만 ES6 Promise는 아직 지원하지 않습니다). 가능한 두 가지 결정은
    • 받지 않다
    • 결의
  4. 재 시도 할 수 없음 (약속에는 재시도 기능이 있다는 약속을 반환 한 원래 기능에 액세스 할 수 있어야합니다.

관찰 가능

  1. 정의 : 함수를 비동기식으로 실행하고 실행시 연속 순서 ( 여러 번 )로 반환 값을 사용하도록 도와줍니다 .
  2. 기본적으로 시간이 지날 때 값을 방출하므로 지연됩니다.
  3. 코딩 작업을 단순화하는 많은 연산자가 있습니다.
  4. 한 운영자 재 시도는 우리가 어떤 조건에 따라 관찰을 재 시도 할 필요도 경우에, 필요할 때마다 다시 시도 할 수 있습니다 retryWhen가 사용할 수 있습니다.

    참고 : 대화식 다이어그램과 함께 운영자 목록은 RxMarbles.com 에서 확인할 수 있습니다.


67

답변에 Observables의 단점이 하나 있습니다. 약속은 ES7 비동기 / 대기 기능을 사용할 수 있습니다. 그것들을 사용하면 동기 함수 호출처럼 비동기 코드를 작성할 수 있으므로 더 이상 콜백이 필요하지 않습니다. Observables가이를 수행 할 수있는 유일한 가능성은 약속으로 변환하는 것입니다. 그러나이를 약속으로 변환하면 다시 한 번의 반환 값만 가질 수 있습니다.

async function getData(){
    const data = await observable.first().toPromise();
    //do stuff with 'data' (no callback function needed)
}

추가 읽을 거리 : Rx Observable에서 어떻게 '기다릴'수 있습니까?


21
또한 비동기 / 대기 덕분에 단순성과 투명성으로 인해 약속의 킬러 특권을 아무도 지적하지 않은 이유도 놀랐습니다. 플랫 코드 작성 기능을 위해 Promises로 전환했습니다. 단순한 비즈니스 로직과 UI 상호 작용 코드는 로켓 과학처럼 보이지 않아야하며 중첩 된 반응성 확장으로 오염 될 수 있습니다. 또한 async / await는 미래 일뿐만 아니라 현재 트랜스 필러를 사용하는 공개 프로덕션 앱에서 사용할 수 있습니다. TypeScript 2.3을 사용하는데 실제 언어처럼 훌륭합니다.
evilkos

멋지지만 반응적인 방식으로 생각하고 RxOperators를 사용하는 것은 아마도 이것이 킬러 기능이 아닐 수도 있습니다.
JorgeTovar

37

약속 및 관찰 가능 항목은 모두 비동기 호출 만 처리합니다.

차이점은 다음과 같습니다.

주목할 만한

  1. 일정 기간 동안 여러 값을 방출
  2. Observable을 구독 할 때까지 호출되지 않습니다
  3. unsubscribe () 메소드를 사용하여 취소 할 수 있습니다
  4. 운영자에게 맵, forEach, 필터링, 축소, 재시도 및 재시도 제공

약속

  1. 한 번에 하나의 값만 방출

  2. .then 및 .catch없이 서비스를 호출합니다.

  3. 취소 할 수 없습니다

  4. 운영자를 제공하지 않습니다


2
promise가 의미하는 바는 단일 값만 방출하는 반면 관찰 가능한 것은 다중 방출
Abel

2
약속은 전혀 가치를 내리지 않습니다. 약속 시간이 지남에 따른 가치입니다. 약속은 여러 가입자에게 그 가치를 멀티 캐스트합니다. 약속을 지키면 이미 가치가 있습니다. 옵저버 블은 함수 와 비슷하며 구독하면 액션을 호출합니다.
Benjamin Gruenbaum

1
@ BenjaminGruenbaum 아직도 여러 가입자의 평균을 얻지 못했습니다 링크 또는 예를 제공 할 수 있습니까? 감사합니다
디팍 Patidar

2
observable1.subscribe (subscriber1), observable1.subscribe (subscriber2)- 함수를 여러 번 호출합니다 .
Benjamin Gruenbaum

2
제발 편집 게시물을 대신 스크린 샷의 실제 텍스트를 표시합니다. 다른 사람들은 이미지에서 복사하여 붙여 넣기를 할 수 없으며 많은 문법 오류를 해결하는 데 도움을 줄 수 없습니다. 자세한 내용은 여기참조하십시오 . 감사합니다.
Pang

26

이 답변이 늦었지만 아래 차이점을 요약했습니다.

주목할 만한:

  1. 관찰 가능한 단지이다 function소요 an observer와 리턴한다 function Observer: an object with next, error.
  2. 관찰자가 허용 subscribe/unsubscribe데이터 스트림, 관찰자 다음 값을 출사 notify대한 관찰자 errors와 관찰자에 대해 알려stream completion
  3. 관찰자는 function to handle next value, 오류 및 스트림 끝 (ui 이벤트, http 응답, 웹 소켓이있는 데이터)을 제공합니다.
  4. multiple values시간 이 지남에 따라 작동
  5. 그것은이다 cancel-able/retry-able과 같은 지원 사업자 등 map,filter,reduce
  6. 피 감시 만들기 될 수있다 - Observable.create()- 메소드를 호출 할 수 복귀 관측 가능한 - Observer Observable.from()-로 배열이나 반복 가능한 변환 - Observable Observable.fromEvent()- - 피 감시에 이벤트를 변환 Observable.fromPromise()- 피 감시로 약속 변환 - Observable.range()- 규정 된 범위 내에서 정수의 시퀀스를 반환

약속 :

  1. 약속은 미래에 끝날 임무를 나타냅니다.

  2. 약속은된다 resolved by a value;

  3. 약속은 예외에 의해 거부됩니다.

  4. 아닙니다 cancellable그리고 그것은 돌려 보냅니다a single value

  5. 약속은 기능을 노출 (then)

    그런 다음 새를 반환합니다 promise.

    -에 attachment기반하여 실행됩니다 state;

    - handlers아르 guaranteed에서 실행 order attached;


20

방금 약속이 가장 좋은 해결책 인 문제를 처리했으며 유용한 경우이 질문을 우연히 해결하는 사람을 위해 여기에서 공유하고 있습니다 (이것은 내가 이전에 찾고 있던 대답이었습니다).

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 방법이 이상적입니다.


3
이것은 (높은 순서의) 관찰 가능 항목에서도 가능합니다. 예를 들어 scan()순차적 관측 가능 스트림을 작성하는 데 사용할 수 있습니다. 그러나 귀하의 접근 방식은 더 명확하고 이해하기 쉽습니다.
lex82

1
"then"을 "switchMap"으로 바꾸고 관찰 가능한 것과 똑같은 일을 할 수 있습니다.
C. Hilarius 박사

1
내가 이해하는 것처럼 switchMap의 문제는 모든 요청을 병렬로 시작하고 모두 반환 될 때까지 기다린 다음 호출 함수에 값을 반환하지만 내 상황에서는 할 수없는 단일 서버가 있다는 것입니다 서버가 새 요청이 들어올 때 완료되지 않은 요청을 삭제하기 때문에 여러 번 병렬로 호출하므로 새 호출을 시작하기 전에 데이터베이스 서비스에 대한 각 호출이 완료되었는지 확인해야했으며 약속 / 최고인 것처럼 보였습니다. 아마도 그것을 해결할 수있는 유일한 방법 일 것입니다.
Stephen R. Smith

1
체인 된 mergeMap을 사용하지 않은 이유는 무엇입니까? 내가 당신의 코드를 이해하는 한, 이것은 매우 간단하며 예제만큼 잘 작동합니다. @ StephenR.Smith
광석

1
@Ore 다른 답변과 동일한 문제를 해결하는 코드 예제를 추가 할 수 있습니까? 좋은 참고 자료가 될 것이며 앞으로 좋은 리팩토링 기회가 될 것입니다. 요구 사항은 백엔드 서비스를 병렬로 호출 할 수없는 코드가 있으면 호출하고 리턴 값을 기다린 후 다시 호출해야한다는 것입니다.
Stephen R. Smith

20

다른 모든 답변은 의심을 없애야한다고 생각합니다. 그럼에도 불구하고, 나는 Observable이 함수형 프로그래밍을 기반으로하고 있다는 것을 덧붙이고 싶었고, map, flatmap, reduce, zip과 같은 기능이 매우 유용하다는 것을 알았습니다. 특히 웹이 API 요청에 의존 할 때 달성하는 일관성은 대단한 개선입니다.

ReactiveX의 공식 문서이므로이 문서를 강력히 추천 합니다 .

관찰 가능 항목에 들어가려면이 3 부분 게시물을 제안합니다 .http : //blog.danlew.net/2014/09/15/grokking-rxjava-part-1/

RxJava를위한 것이지만 개념은 동일하며 실제로 잘 설명되어 있습니다. ReactiveX 문서에는 각 기능에 해당하는 내용이 있습니다. RxJS를 찾아야합니다.


18

약속:

  • 단일 미래 가치를 제공하십시오.
  • 게으른;
  • 취소 할 수 없습니다.

주목할 만한:

  • 시간이 지남에 따라 여러 값을 방출합니다.
  • 게으른;
  • 취소 가능;
  • 지도, 필터링, 축소 및 유사한 연산자 지원

원하는 경우 Angular에서 HTTP를 호출 할 때 옵저버 블 대신 약속을 사용할 수 있습니다.


16

개요 :

  • Promises와 Observables는 비동기 작업을 처리하는 데 도움이됩니다. 이러한 비동기 작업이 완료되면 특정 콜백을 호출 할 수 있습니다.
  • Promise는 하나의 이벤트 만 처리 할 수 ​​있으며 Observable은 시간이 지남에 따라 이벤트 스트림에 사용됩니다.
  • 보류중인 약속은 취소 할 수 없습니다
  • 연산자를 사용하여 데이터 Observable 방출을 변환 할 수 있습니다

옵저버 블에는 약속이 제공하는 모든 기능 (+ 추가)이 있으므로 비동기식 동작을 처리하기 위해 항상 옵저버 블을 사용할 수 있습니다. 그러나 때때로 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를 사용하는 경우 :

처리해야하는 시간지남에 따라 데이터 스트림 이있는 경우 Observables를 사용하십시오 . 스트림은 시간이 지남에 따라 사용 가능한 일련의 데이터 요소입니다 . 스트림의 예는 다음과 같습니다.

  1. 클릭 또는 키업 이벤트와 같은 사용자 이벤트 사용자는 시간이 지남에 따라 이벤트 (데이터)를 생성합니다.
  2. 웹 소켓은 클라이언트가 서버에 WebSocket 연결을 한 후 시간이 지남에 따라 데이터를 푸시합니다.

관찰에서 자체는 때 지정된 다음 이벤트가 일어난 경우, 오류가 발생 하거나 관찰이 될 때 완료 . 그런 다음이 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이 구독되면 구독에 전달 된 해당 콜백을 호출합니다.


9

약속-미래의 단일 가치를 제공하십시오. 게으르지 않습니다. 취소 할 수 없습니다. 거부하거나 해결합니다.

관찰 가능-여러 미래 가치를 제공합니다. 게으른 취소 가능 그것은 다른 방법 라이브 맵, 필터, 감소를 제공합니다.


8

약속 대 관찰 가능한 유사성

  1. 둘 다 비동기 코드를 처리하는 데 사용되었습니다.
  2. 약속의 예를 찾으십시오. Promise 생성자는 비동기 작업이 완료되면 어떤 값으로 호출 될 때 호출되는 resolve reference 함수를 전달합니다.

const promise = new Promise(resolve => {
  setTimeout(() => {
    resolve("Hello from a Promise!");
  }, 2000);
});

promise.then(value => console.log(value));

  1. 이제 관찰 가능한 예입니다. 여기에서는 비동기 작업을 처리하는 관찰자, 관찰자에게 함수를 전달합니다. 약속의 resolve와 달리 다음 방법이 있으며 대신 구독합니다.

  2. 따라서 둘 다 비동기 작업을 처리합니다. 이제 차이점을 보자.


const observable = new Observable(observer => {
  setTimeout(() => {
    observer.next('Hello from a Observable!');
  }, 2000);
});

observable.subscribe(value => console.log(value));

약속과 관찰 가능한 차이

약속

  1. 단일 값을 해결하거나 거부하며 한 번에 단일 값 비동기 작업을 처리 할 수 ​​있습니다.
  2. 약속은 완료된 비동기 값을 한 번 해결하고 더 이상 사용할 수 없으며 한 번만 사용하면 부족합니다.
  3. 취소 불가
  4. 운영자를위한 rxjs 지원이 없습니다.

주목할 만한

  1. 여러 비동기 값을 방출하는 기능.
  2. 이벤트 또는 값의 스트림을 처리하는 데 사용됩니다. 수많은 작업 또는 값이 배열되어 있고 값이 삽입 될 때마다 자동으로 처리되어야한다고 생각하십시오. 이 배열에 값을 넣을 때마다 모든 구독자가 최신 값을 자동으로받습니다.
  3. Observable은 입력 변경, 반복 간격, 모든 하위 구성 요소에 브로드 캐스트 값, 웹 소켓 푸시 알림 등을 관찰하는 데 유용합니다.
  4. 구독 취소 방법을 사용하여 언제든지 취소 할 수 있습니다.
  5. 약속 한 또 다른 좋은 부분은 rxjs 연산자를 지원하는 것입니다. 구독하기 전에 관찰 가능한 데이터를 변환하기 위해 많은 파이프 연산자가 주로 맵, 필터, switchMap, combineLatest 등을 가지고 있습니다.

여기에 이미지 설명을 입력하십시오



6

Promises와 Observables는 비동기 작업을 처리하는 데 도움이됩니다. 이러한 비동기 작업이 완료되면 특정 콜백을 호출 할 수 있습니다.

Angular는 HTTP 처리 약속 대신 RxJS의 Observable을 사용합니다.

Below are some important differences in promises & Observables.

약속과 관찰자의 차이점


1
표로 정리 된 데이터가 올바르지 않은 것 같습니다. 제목이
바뀌어야합니다.

1
제발 편집 게시물을 텍스트 대신 스크린 샷과 실제 내용을 보여줍니다. 다른 사람들은 이미지에서 복사하여 붙여 넣을 수 없습니다. 자세한 내용은 여기참조하십시오 . 감사합니다.
Pang

6

비동기 활동이 완료되거나 실패하면 약속은 단일 이벤트를 생성합니다.

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를 사용하여 비동기 데이터를 처리 할 수 ​​있습니다. 해당 데이터가 일정 시간 동안 단일 값 또는 다중 값으로 전송되는지 여부

약속:

  • 약속은 게으르지 않다
  • 약속을 취소 할 수 없습니다

주목할 만한:

  • 관찰 가능한 게으른입니다. "관찰 가능"이 느립니다. 구독 할 때까지 호출되지 않습니다.
  • unsubscribe () 메소드를 사용하여 Observable을 취소 할 수 있습니다.
  • Observable은 map, foreach, filter, reduce, retry, retryWhen 등과 같은 많은 강력한 연산자를 제공합니다.

각도 약속과 관찰 가능


5

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

3

아래는 약속과 관찰의 중요한 차이점입니다.

약속

  • 단일 값만 방출
  • 취소 불가
  • 공유 불가
  • 항상 비동기

주목할 만한

  • 여러 값을 방출
  • 호출되거나 누군가가 구독중인 경우에만 실행
  • 취소 가능
  • 여러 가입자가 공유 가치를 공유하고 구독 할 수 있습니다. 그리고 모든 가입자는 단일 시점에서 실행됩니다.
  • 아마도 비동기

더 나은 이해를 위해 https://stackblitz.com/edit/observable-vs-promises를 참조 하십시오


3

나는 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


2

짧은 답변 :

Observable더 좋으며 , 모든 Promises 기능과 추가 기능이 있습니다.


긴 대답 :

약속 :

  • 한 번 사용 "데이터를 한 번 반환"
  • 취소 안함
  • 하나의 청취자
  • 소켓 지원 없음 리스너

주목할 만한:

  • 데이터가 변경되면 여러 번 데이터 반환
  • 지원 취소
  • 지지 소켓
  • 많은 리스너 지원 및 데이터 변경시 알림
  • 지원 맵, 필터, 축소

Observables가 객관적으로 낫다고 말할 수는 없다고 생각합니다. 여기에 다양한 답변에 언급 된 Observables에 대한 단점이 있습니다. 나에게 눈에 띄는 것은 Observable의 복잡성이며 대기 / 비동기식으로 직접 작동하지 않는다는 것입니다. Observable을 사용할 때 동작을 결정할 수 없기 때문에 개인적으로 작동하기가 어렵다는 것을 알게되었습니다. 코드를 생성 한 코드를 봐야합니다. 약속과 함께, 당신은 항상 그들이 어떻게 작동하는지 정확히 알고 있습니다. 예를 들어, Observable에 가입하면 때로는 부작용 (예 : http 요청)이 있지만 때로는 그렇지 않습니다.
Yona Appletree

각도의 경우 케이스에 따라 다릅니다. 대부분의 경우 우리는 다른 장소, 소켓, 취소,지도, 필터링 및 축소에 영향을 미치는 서비스 및 일부 데이터로 작업합니다. 따라서 지원하지 않는 약속으로 그러한 경우에 더 좋습니다. 그래서 다시는 경우에 따라
아 므르 이브라힘

2

허용되는 대답은 일반적으로 좋지만 각도 구성 요소를 다룰 때 취소를 지원하기 때문에 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


2

내가 강의 한 것은 튜토리얼과 문서를 처음 읽었을 때 분명하지 않았지만 멀티 캐스팅이라는 아이디어였습니다.

기본적으로 여러 구독이 Observable에서 여러 실행을 트리거한다는 것을 알고 있어야합니다. 단일 HTTP 호출에 대한 다중 구독 Observable은 .share()멀티 캐스팅을 활성화 하지 않는 한 동일한 HTTP 호출을 여러 번 트리거합니다 .

약속은 한 번에 한 가지만 처리하고, 데이터를 압축 해제하고, 예외를 처리하고, 비동기 / 대기 등의 멋진 기능에 대한 언어 지원을 제공하며, 그렇지 않은 경우에는 매우 중요합니다.

Observable은 많은 종과 휘파람을 가지고 있지만 작업하는 힘을 이해해야하거나 잘못 사용할 수 있습니다.


2

약속:

비동기 이벤트 처리기-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



1

옵저버 블은 종종 약속과 비교됩니다. 주요 차이점은 다음과 같습니다.

관찰 가능한 내용은 선언적입니다. 가입 할 때까지 계산이 시작되지 않습니다. 약속은 창조 즉시 실행됩니다. 이것은 결과물이 필요할 때마다 실행될 수있는 레시피를 정의하는 데 관측 값을 유용하게 만듭니다.

Observable은 많은 가치를 제공합니다. 약속은 하나를 제공합니다. 따라서 관측 가능 항목은 시간이 지남에 따라 여러 값을 가져 오는 데 유용합니다.

옵저버 블은 체인과 구독을 구분합니다. 약속에는 .then () 절만 있습니다. 이로 인해 Observables는 작업을 실행하지 않고도 시스템의 다른 부분에서 사용할 복잡한 변환 레시피를 만드는 데 유용합니다.

Observables subscribe ()는 오류 처리를 담당합니다. 약속은 자녀의 약속에 오류를 미칩니다. 이는 관측 가능 항목을 중앙 집중식 및 예측 가능한 오류 처리에 유용하게 만듭니다.

이것이 ANGULAR.IO 문서에서 찾을 수있는 가장 간단한 차이점입니다. 나머지 답변은 대부분 자체 장소에서 정확합니다.


1
  1. 약속은 단일 값 또는 해결에만 초점을 맞추고 관찰 가능한 데이터 스트림입니다.

  2. 옵저버 블은 취소 할 수 있지만 약속은 취소 할 수 없습니다.

나에게 가장 잘 알려진 것은

  1. 약속은 항상 비동기 적이지만 관찰 가능 항목은 동기식과 비동기식 일 수 있습니다.

0
  1. 약속은 간절하지만 Observable은 게으르고
  2. Promise는 항상 비동기식이지만 Observable은 동기식 또는 비동기식 일 수 있습니다.
  3. Promise는 단일 값을 제공 할 수 있지만 Observable은
    값 스트림 (0에서 여러 값까지)입니다.
  4. RxJS 연산자를 Observable에 적용하여 새로운 맞춤형 스트림을 얻을 수 있습니다.

-1

Observables 및 Promises는 JavaScript / typescript의 비동기 기능을 사용하는 데 도움을줍니다. 많은 경우에 매우 유사하지만 여전히 약간의 차이가 있습니다.

여기에 이미지 설명을 입력하십시오


1
제발 편집 게시물을 대신 스크린 샷의 실제 텍스트를 표시합니다. 다른 사람들은 이미지에서 복사하여 붙여 넣을 수 없습니다. 자세한 내용은 여기참조하십시오 . 감사합니다.
Pang

코드가 아닌 일반 정보를 제외하고는 이미지로 게시해도 괜찮습니다.
Alator

1
Kudvenkat의 YouTube 동영상에서 붙여 넣기를 중지합니다. 나에게서 공감! :)
Pratik

-2

이 주제에 대해 이미 많은 답변이 있으므로 중복 항목을 추가하지 않습니다.

그러나 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입니다.

당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.