Which is Better Reactive Programming Libraries?
rxjs vs rxjs-compat
1 Year
rxjsrxjs-compatSimilar Packages:
What's Reactive Programming Libraries?

RxJS (Reactive Extensions for JavaScript) is a library for composing asynchronous and event-based programs using observable sequences. It provides a powerful way to work with asynchronous data streams, enabling developers to manage events, asynchronous calls, and data transformations in a declarative manner. RxJS-compat is a compatibility layer that allows developers to migrate from RxJS version 5 to version 6 without having to refactor their existing code immediately. It provides the same API as RxJS 5, making it easier to transition to the newer version while maintaining existing functionality.

NPM Package Downloads Trend
Stat Detail
Package
Downloads
Stars
Size
Issues
Publish
License
rxjs43,068,81130,7254.5 MB266a year agoApache-2.0
rxjs-compat295,352---4 years agoApache-2.0
Feature Comparison: rxjs vs rxjs-compat

API Design

  • rxjs: RxJS offers a rich set of operators and a more modular approach to handling asynchronous data streams. It introduces a new way of composing operations using pipeable operators, which can be more efficient and easier to read compared to the previous version.
  • rxjs-compat: RxJS-compat maintains the API of RxJS 5, allowing developers to use the same operators and methods without modification. This makes it easier for teams to transition without needing to rewrite their existing code immediately.

Performance

  • rxjs: RxJS 6 introduces performance optimizations, including better tree-shaking capabilities, which help reduce the final bundle size by allowing unused code to be eliminated during the build process. This results in faster load times and improved application performance.
  • rxjs-compat: While RxJS-compat allows for backward compatibility, it does not include the performance enhancements of RxJS 6. Using rxjs-compat may lead to larger bundle sizes and slower performance compared to using the latest RxJS.

Learning Curve

  • rxjs: RxJS has a steeper learning curve due to its extensive set of operators and concepts like Observables, Subjects, and Schedulers. However, mastering these concepts can significantly enhance a developer's ability to manage complex asynchronous workflows effectively.
  • rxjs-compat: RxJS-compat is easier for developers familiar with RxJS 5, as it allows them to continue using the same patterns and practices without needing to learn the new API immediately. This can ease the transition for teams with existing codebases.

Community and Support

  • rxjs: RxJS has a large and active community, with extensive documentation, tutorials, and resources available. This support makes it easier for developers to find solutions to problems and learn best practices.
  • rxjs-compat: RxJS-compat, while useful for migration, is not actively developed and may not receive the same level of community support as RxJS. Developers are encouraged to transition to RxJS for long-term support and updates.

Future-Proofing

  • rxjs: Using RxJS ensures that your application is built on the latest standards and features, making it more adaptable to future changes in the ecosystem. It is actively maintained and updated, ensuring compatibility with new JavaScript features and frameworks.
  • rxjs-compat: RxJS-compat is intended as a temporary solution for migration. Relying on it for the long term may hinder your application's ability to leverage new features and improvements available in RxJS.
How to Choose: rxjs vs rxjs-compat
  • rxjs: Choose RxJS if you are starting a new project or if you want to take advantage of the latest features and performance improvements. RxJS provides a more modern API and better support for tree-shaking, which can help reduce bundle size.
  • rxjs-compat: Choose RxJS-compat if you have an existing codebase that relies on RxJS 5 and you need to upgrade to RxJS 6 gradually. It allows you to maintain your current code while you refactor it to use the new RxJS 6 API.
README for rxjs

RxJS Logo RxJS: Reactive Extensions For JavaScript

CI npm version Join the chat at https://gitter.im/Reactive-Extensions/RxJS

The Roadmap from RxJS 7 to 8

Curious what's next for RxJS? Follow along with Issue 6367.

RxJS 7

FOR 6.X PLEASE GO TO THE 6.x BRANCH

Reactive Extensions Library for JavaScript. This is a rewrite of Reactive-Extensions/RxJS and is the latest production-ready version of RxJS. This rewrite is meant to have better performance, better modularity, better debuggable call stacks, while staying mostly backwards compatible, with some breaking changes that reduce the API surface.

Apache 2.0 License

Versions In This Repository

  • master - This is all of the current work, which is against v7 of RxJS right now
  • 6.x - This is the branch for version 6.X

Most PRs should be made to master.

Important

By contributing or commenting on issues in this repository, whether you've read them or not, you're agreeing to the Contributor Code of Conduct. Much like traffic laws, ignorance doesn't grant you immunity.

Installation and Usage

ES6 via npm

npm install rxjs

It's recommended to pull in the Observable creation methods you need directly from 'rxjs' as shown below with range. If you're using RxJS version 7.2 or above, you can pull in any operator you need from the same spot, 'rxjs'.

import { range, filter, map } from 'rxjs';

range(1, 200)
  .pipe(
    filter(x => x % 2 === 1),
    map(x => x + x)
  )
  .subscribe(x => console.log(x));

If you're using RxJS version below 7.2, you can pull in any operator you need from one spot, under 'rxjs/operators'.

import { range } from 'rxjs';
import { filter, map } from 'rxjs/operators';

range(1, 200)
  .pipe(
    filter(x => x % 2 === 1),
    map(x => x + x)
  )
  .subscribe(x => console.log(x));

CDN

For CDN, you can use unpkg:

https://unpkg.com/rxjs@^7/dist/bundles/rxjs.umd.min.js

The global namespace for rxjs is rxjs:

const { range } = rxjs;
const { filter, map } = rxjs.operators;

range(1, 200)
  .pipe(
    filter(x => x % 2 === 1),
    map(x => x + x)
  )
  .subscribe(x => console.log(x));

Goals

  • Smaller overall bundles sizes
  • Provide better performance than preceding versions of RxJS
  • To model/follow the Observable Spec Proposal to the observable
  • Provide more modular file structure in a variety of formats
  • Provide more debuggable call stacks than preceding versions of RxJS

Building/Testing

  • npm run compile build everything
  • npm test run tests
  • npm run dtslint run dtslint tests

Adding documentation

We appreciate all contributions to the documentation of any type. All of the information needed to get the docs app up and running locally as well as how to contribute can be found in the documentation directory.