### Use Piping Instead of Chaining Use piping instead of chaining as new operator syntax. The result of one operator is piped into another operator. Don't remove `rxjs-compat` until you have refactored all chained operators into piped operators. If you are a TypeScript user, `ts-lint` can automate this refactoring to some extent for well-typed code. During [ng-conf 2018](https://www.ng-conf.org/sessions/introducing-rxjs6/), Ben Lesh explained [why we should use pipeable operators](https://youtu.be/JCXZhe6KsxQ?t=2m30s):  Follow these steps to reactor your operator chains into pipes: - Install all operators used from `rxjs/operators`. > **Note** Some operators have a name change due to name collisions with JavaScript reserved words! These include: `do` -> `tap`, `catch` -> `catchError`, `switch` -> `switchAll`, `finally` -> `finalize`. ```javascript import { map, filter, catchError, mergeMap } from "rxjs/operators"; ``` - Attach a [`pipe()`](http://reactivex.io/rxjs/class/es6/Observable.js~Observable.html#instance-method-pipe) method to the source and wrap all the operators within it. Ensure that the `.` is removed from each operator name and that they are comma-delimited. Remember that some operators need to change their names. The following is an example of a pipeable refactoring from the release notes: ```javascript // an operator chain source .map(x => x + x) .mergeMap(n => of(n + 1, n + 2) .filter(x => x % 1 == 0) .scan((acc, x) => acc + x, 0) ) .catch(err => of("error found")) .subscribe(printResult); // must be updated to a pipe flow source .pipe( map(x => x + x), mergeMap(n => of(n + 1, n + 2).pipe( filter(x => x % 1 == 0), scan((acc, x) => acc + x, 0) ) ), catchError(err => of("error found")) ) .subscribe(printResult); ``` Notice how we use `pipe()` twice in the above code as internal sources are also piped. ### Use Functions instead of Classes Functions have replaced classes that operate on observables. All [observable classes](https://github.com/ReactiveX/rxjs/tree/5.5.8/src/observable) have been removed. Their functionality is replaced by existing operators, new operators, or functions. Each of their replacement has the same functionality that each class had. For example: ```javascript // removed ArrayObservable.create(myArray) // use instead from(myArray) // you may also use new operator fromArray(). ``` For a complete list of the `v6` creation functions that replace `v5` classes, please visit the [RxJS documentation](https://github.com/ReactiveX/rxjs). **Special case:** - [`ConnectableObservable`](https://github.com/ReactiveX/rxjs/blob/master/src/internal/observable/ConnectableObservable.ts) is hidden from direct use in `v6`. To access it, use the operators [`multicast`](http://reactivex.io/rxjs/class/es6/Observable.js~Observable.html#instance-method-multicast), [`publish`](http://reactivex.io/rxjs/class/es6/Observable.js~Observable.html#instance-method-publish), [`publishReplay`](http://reactivex.io/rxjs/class/es6/Observable.js~Observable.html#instance-method-publishReplay), [`publishLast`](http://reactivex.io/rxjs/class/es6/Observable.js~Observable.html#instance-method-publishLast). - [`SubscribeOnObservable`](https://github.com/ReactiveX/rxjs/blob/master/spec/observables/SubscribeOnObservable-spec.ts) is hidden from direct use in `v6`. To access it, use the operator [`subscribeOn`](http://reactivex.io/rxjs/class/es6/Observable.js~Observable.html#instance-method-subscribeOn). ### Removing resultSelector Result selectors are a RxJS feature that is not widely used and in some cases wasn't even documented. However, result selectors did bloat the codebase significantly; thus, the RxJS team decided to deprecate or remove them. For developers making use of result selectors, they would need to replace the `resultSelector` parameter with external result-selection code. For two functions, [`first()`](http://reactivex.io/rxjs/class/es6/Observable.js~Observable.html#instance-method-first) and [`last()`](http://reactivex.io/rxjs/class/es6/Observable.js~Observable.html#instance-method-last) these parameters have been removed and must be updated before removing `rxjs-compat`. For other functions that have `resultSelector` as a parameter, such as mapping operators, this parameter has been deprecated and their implementation has been re-written in a much more compact form. If you remove `rxjs-compat`, these function will continue to work; however, the RxJS team states that they must be removed before the `v7` release. For more details on this rare implementation, please visit the [RxJS documentation](https://github.com/ReactiveX/rxjs). ## Other RxJS 6 Deprecations ### `Observable.if` and `Observable.throw`. [`Observable.if`](http://reactivex.io/rxjs/file/es6/observable/if.js.html) has been replaced by [`iif()`](https://github.com/ReactiveX/rxjs/blob/master/src/internal/observable/iif.ts) and [`Observable.throw`](http://reactivex.io/rxjs/file/es6/observable/throw.js.html) is now [`throwError()`](https://github.com/ReactiveX/rxjs/blob/master/src/internal/observable/throwError.ts). You can use `rxjs-tslint` to convert these deprecated `Observable` method calls into function calls. The release notes gives us the following example: #### Observable.if > iif() ```javascript // deprecated Observable.if(test, a$, b$); // use instead iif(test, a$, b$); ``` #### Observable.error > throwError() ```javascript // deprecated Observable.throw(new Error()); //use instead throwError(new Error()); ``` ### Deprecated Methods According to the migration guide, other methods have been deprecated and refactored: **merge** ```javascript import { merge } from "rxjs/operators"; a$.pipe(merge(b$, c$)); // becomes import { merge } from "rxjs"; merge(a$, b$, c$); ``` **concat** ```javascript import { concat } from "rxjs/operators"; a$.pipe(concat(b$, c$)); // becomes import { concat } from "rxjs"; concat(a$, b$, c$); ``` **combineLatest** ```javascript import { combineLatest } from "rxjs/operators"; a$.pipe(combineLatest(b$, c$)); // becomes import { combineLatest } from "rxjs"; combineLatest(a$, b$, c$); ``` **race** ```javascript import { race } from "rxjs/operators"; a$.pipe(race(b$, c$)); // becomes import { race } from "rxjs"; race(a$, b$, c$); ``` **zip** ```javascript import { zip } from "rxjs/operators"; a$.pipe(zip(b$, c$)); // becomes import { zip } from "rxjs"; zip(a$, b$, c$); ``` ## Recap RxJS 6 brings some breaking changes but they are mitigated by the addition of the `rxjs-compat` package that allows you to gradually migrate while keeping your `v5` code operational. For TypeScript users, which cover the majority of Angular developers, `tslint` offers a great deal of automated refactoring to make the transition even easier. As always, any upgrades and code changes may invite bugs into the codebase or even make elusive ones resurface. Solid testing practices should always be in place to ensure that your users keep receiving the same quality experience that you were providing them when `v5` was part of your codebase. Watch the complete introduction to RxJS 6 by Ben Lesh:Have you tried updating your app using rxjs-tslint?
— Ben Lesh 🛋️👑🔥 (@BenLesh) April 25, 2018