Promise

<>Promise>Promise,当“inc”号业务完成或失败时,可操作single activity。

注:有<编码>Promise/code> Library out that support abolition, but ES6 Promise don t 迄今。

<>可见>

<Observable 就像>>(以多种语文),并允许你在每次活动都要求回响时通过零或更多活动。

通常Observable优于Promise,因为它提供了Promise等特征。 如果你想处理0、1或多个事件,则使用<条码>可保存<>。 你们可以利用每种情况下的同样版本。

。 如果远洋班轮公司向服务器或某些其他昂贵的同业经营申请的结果不再需要,则<代码>的代谢/代码>。 可观测允许你取消订阅,而<编码>Promise即使你不需要通知或结果,也最终会称其成功或失败。

虽然<代码>Promise立即开始,但 可观测只有在您签署时才开始。 因此,观测站被称为 la。

词汇表仅包括两个文档:<代码>app.ts和wikipedia-service.ts/code>。 在一个现实的世界形势下,我们很可能进一步分裂事情。

<代码>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]);
  }
}

We are injecting the Jsonp service to make a GET request against the Wikipedia API with a given search term. Notice that we call toPromise in order to get from an Observable<Response> to a Promise<Response>. Eventually end up with a Promise<Array<string>> as the return type of our search method.

<代码>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);
  }
}

There is not much of a surprise here either. We inject our WikipediaService and expose its functionality via a search method to the template. The template simply binds to keyup and calls search(term.value).

我们不理会的查询方法,即Wikipediaservice的返回,把它作为简单系列的示意图,以使我们能够有*纳克。 通过该格式,并为我们编制一个清单。

为了揭开这种超级大国,我们首先需要一个<代码>。 Observable<string>, 该词含有用户类型中的搜索术语。 我们不是对关键活动具有人工约束力,而是能够利用Angular's formControl指令。 为了使用这一指令,我们首先需要将输入我们的应用模块。

<代码>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 {}

一旦进口,我们就可以在模板内使用“Control”,将其命名为“定期”。

<input type="text" [formControl]="term"/>

在我们的构成部分中,我们从@angular/form中创立了一个“”的例子,并将其列为我们组成部分的名词下的一个领域。

在幕后,term自动暴露了Observable<string>,作为我们可以订阅的财产。 现在,我们有<条码>可加利用的加固;斯特鲁特”;,克服用户的投入,如同在<条码>上打上<条码>(400)一样容易。 可见。 新的<代码> Observable<string >, that will only emit a new Value when there haven's has not come new Value for 400 ms.

export class App {
  items: Array<string>;
  term = new FormControl();
  constructor(private wikipediaService: WikipediaService) {
    this.term.valueChanges
              .debounceTime(400)        // wait for 400 ms pause in events
              .distinctUntilChanged()   // ignore if next search term is same as previous
              .subscribe(term => this.wikipediaService.search(term).then(items => this.items = items));
  }
}

我们的申请已经表明结果,这是浪费资源,无法再提出搜索要求。 为实现所期望的行为,我们必须做的是,在我们称之为<代码>debouncetime(400)之后,打上“<0>>。

See example of Observable implementation on Plunker

For dealing with out-of-order responses, please check the full article http://blog.thoughtram.io/angular/2016/01/06/taking-advantage-of-observables-in-angular2.html

就我在安吉斯使用吉卜赛人,我同意,在通常使用情况下,在使用可观测到的超声器时没有什么区别。 这里没有任何好处在实际中是有意义的。 我希望,我能看到今后出现一些先进的使用案例:

学习更多

• https://angular-2-training-book.rangle.io/handout/observables/
• https://angular.io/tutorial/toh-pt6#observables

<>Promises和Observables将帮助我们在 Java本中利用同步功能。 然而,在许多情况下,这两种做法之间仍然有一些差别,因此,在<条码>上将解决的价值观。 象吉大港山区倡议那样。 另一方面,观测站处理了一系列的同步活动。 两者的主要差别如下:

<<>Promise>:

• having one pipeline
• usually only use with async data return
• not easy to cancel

<>可见>

• are cancellable
• are re-triable by nature such as retry and retryWhen
• stream data in multiple pipelines
• having array-like operations like map, filter etc
• can be created from other sources like events
• they are functions, which could be subscribed later on

此外,我为以下各位树立了图形形象,以直观显示差异:

There is one downside of Observables missing in the answers. Promises allow to use the ES7 async/await functions. With them you can write asynchronous code like it would be a synchronous function call, so you don t need callbacks anymore. The only possibility for Observables to do this, is to convert them to Promises. But when you convert them to Promises, you can only have one return value again:

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

进一步读: • 如何就可观测到的海洋生物进行“海洋”?

1. Observable is just a function that takes an observer and returns a function Observer: an object with next, error.
2. Observer allows you to subscribe/unsubscribe to its data stream, emit next value to the observer, notify the observer about errors and inform the observer about the stream completion
3. Observer provides a function to handle next value, errors and end of stream (UI events, http responses, data with web sockets).
4. Works with multiple values over time
5. It is cancel-able/retry-able and supports operators such as map, filter, reduce, etc.
6. Creating an Observable can be -Observable.create() - returns Observable that can invoke methods on -Observer Observable.from() - converts an array or iterable into -Observable Observable.fromEvent() - converts an event into Observable -Observable.fromPromise() - converts a Promise into Observable -Observable.range() - returns a sequence of integers in the specified range

<>Promise

1. 承诺是一项未来将完成的任务;

2. 日期改为,由价值>解决;

3. 不允许例外;

4. http://www.strong>。

5. 允诺暴露出一个功能(then)。

   - 回到一个新的<><><>/code>;

   -allows for the attachment of that will be executed based on state;

   - 《<<><>条码>中<>handlers<>>>>><>>>>>><>条码><>>>>>>>> ><<<<>t>>>>>>>>>>>>>>>>>>> ><<>条码><>>>>>>>>>>>>> ><>印有<>条码>>>>印有>>>>>>>>>guarante>>>>><>>>>>>>>>>>>>> > > 印有<> 印有<>>>>>>>>>> 印有<>>>>>>>> 印有<>>>>>>>>> 印有<>>>>>>>>>>>> 印有>>>>>>>>>> 印有>>> 印有<>>> 印有<>>>>

I believe all the other answers should clear your doubts. Nevertheless, I just wanted to add that observables are based on functional programming, and I find very useful the functions that come with it like map, flatmap, reduce, zip. The consistency the web achieves especially when it depends on API requests is a brutal improvement.

我强烈建议,因为该文件载有被动反应的正式文件。 我认为,这是这方面最清楚的。

If you want to get into observables, I would suggest this 3-part post: http://blog.danlew.net/2014/09/15/grokking-rxjava-part-1/

虽然这是对RxJava的意思,但是这些概念是一样的,它确实作了很好的解释。 在被动式X文件中,每个职能都有等同。 你们必须看着RxJS。

Overview:

• Both Promises and Observables help us dealing with asynchronous operations. They can call certain callbacks when these asynchronous operations are done.
• A Promise can only handle one event, Observables are for streams of events over time
• Promises can t be cancelled once they are pending
• Data Observables emit can be transformed using operators

你们总是能够使用一种可观测的办法来处理不合时宜的行为,因为可以观察到的行为具有所有功能,允诺(+外加)。 然而,有时不需要观测站提供的这种额外功能。 然后,进口一个图书馆供图书馆使用,会带来额外的间接费用。

When to use Promises:

如果你有“<>single,作为你想要处理结果的合成物,则使用承诺。 例如:

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

So a promise executes some code where it either resolves or rejects. If either resolve or reject is called the promise goes from a pending state to either a resolved or rejected state. When the promise state is resolved the then() method is called. When the promise state is rejected, the catch() method is called.

When to use Observables:

Use Observables when there is a stream (of data) over time which you need to be handled. A stream is a sequence of data elements which are being made available over time. Examples of streams are:

1. User events, e.g. click, or keyup events. The user generates events (data) over time.
2. Websockets, after the client makes a WebSocket connection to the server it pushes data over time.

In the Observable itself is specified when the next event happened, when an error occurs, or when the Observable is completed. Then we can subscribe to this observable, which activates it and in this subscription, we can pass in 3 callbacks (don t always have to pass in all). One callback to be executed for success, one callback for error, and one callback for completion. For example:

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

在建立可观测站时,需要一种可提供观察员作为理由的反馈功能。 在这位观察员上,您可打电话on Next,onCompleted,onError。 那么,当该表被订阅时,该表就会把相应的呼吁书报到。

我刚才谈到一个问题,即市长是最佳解决办法,我在这里与大家分享,如果这个问题有用的话,我会在这里讨论这个问题(这正是我先前所寻求的答案):

在“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;
          })  }

我界定了该构成部分的职能,然后将DropDowns()改为ngOnit。

独角兽部队的功用是一种假冒,因此,第一件叫随头的人穿着第一个名单Code,而当假装时,回报值就出现在.区的数据变数中,我们可以为此分配数据。 第一变量。 由于该职能已归还数据,我们知道该服务已经完成,而且可以安全地再次使用第二个名单Code,因此,返回价值在下一个.块的数据变数中,我们对此予以分配。 第二类变数。

我们能够按要求把所有变数集中起来,在最后的法典中,我们只是排除了回报声明,并停止了封锁。

这是一种非常具体的使用案例,即我们有一个单一服务,需要多次作为组成部分启动,而且服务必须完成手提并收回价值,然后才能再次被称作,但在这种情况下,宣传/宽容方法是理想的。

Promise:

• Provide a single future value;
• Not lazy;
• Not cancellable;

Observable:

• Emits multiple values over time;
• Lazy;
• Cancellable;
• Supports map, filter, reduce and similar operators

You can use promises instead of observables when calling HTTP in Angular if you wish.

Promise vs Observable similarity first

1. 这两条都用于处理合成法。

2. 请举出许诺的例子。 允诺的施工者通过一个决心的参考功能,在完成某些合成任务时,这种功能会得到某种价值的要求。

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

3. 可见的实例。 在这里,我们通过一个可以观察的职能——一个观察员处理“合成”任务。 与承诺中的决心不同的是,它有以下方法,并签署了协议。

4. 因此,这两者都承担共同的任务。 现在请看差异。

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

Promise vs Observable difference

<>Promise

1. It resolves or reject a single value and can handle a single value async task at a time.
2. A promise once resolved the async value it completes, can no longer be used.its just one-time use and here it falls short.
3. Not cancellable
4. No rxjs support for operators.

<>可见>

1. • 能够提供多种超常价值。

2. 用于处理各种事件或价值观。 认为你有许多任务或价值,你希望每次都列入价值,应当自动处理。 如果你把价值推向这一阵列,其所有用户都将自动获得最新价值。

3. 观测台有助于观察投入的变化、反复的间隔、向所有儿童部分播放的价值观、网上的推动通知等。

4. Can be cancelled using unsubscribe method anytime.

5. 另一项承诺是支持游轮经营者。 你们有许多管道操作者主要绘制地图、过滤器、开关卡、结合测试等,以便在安装之前改变可观测的数据。

   

Promise - Provides a single future value. Not lazy. Not cancel-able. It will either reject or resolve.

可观测——提供多种未来价值。 Lazy。 Cancel-able. 它提供了其他方法,如map、filter<>em>和reduce。